diff --git a/include/hardware/audio_effect.h b/include/hardware/audio_effect.h
index 46e323d..2c8f2e3 100644
--- a/include/hardware/audio_effect.h
+++ b/include/hardware/audio_effect.h
@@ -873,8 +873,10 @@
 //      Effect library interface
 /////////////////////////////////////////////////
 
-// Effect library interface version 2.0
-#define EFFECT_LIBRARY_API_VERSION EFFECT_MAKE_API_VERSION(2,0)
+// Effect library interface version 3.0
+// Note that EffectsFactory.c only checks the major version component, so changes to the minor
+// number can only be used for fully backwards compatible changes
+#define EFFECT_LIBRARY_API_VERSION EFFECT_MAKE_API_VERSION(3,0)
 
 #define AUDIO_EFFECT_LIBRARY_TAG ((('A') << 24) | (('E') << 16) | (('L') << 8) | ('T'))
 
@@ -893,57 +895,6 @@
 
     ////////////////////////////////////////////////////////////////////////////////
     //
-    //    Function:        query_num_effects
-    //
-    //    Description:    Returns the number of different effects exposed by the
-    //          library. Each effect must have a unique effect uuid (see
-    //          effect_descriptor_t). This function together with EffectQueryEffect()
-    //          is used to enumerate all effects present in the library.
-    //
-    //    Input/Output:
-    //          pNumEffects:    address where the number of effects should be returned.
-    //
-    //    Output:
-    //        returned value:    0          successful operation.
-    //                          -ENODEV     library failed to initialize
-    //                          -EINVAL     invalid pNumEffects
-    //        *pNumEffects:     updated with number of effects in library
-    //
-    ////////////////////////////////////////////////////////////////////////////////
-    int32_t (*query_num_effects)(uint32_t *pNumEffects);
-
-    ////////////////////////////////////////////////////////////////////////////////
-    //
-    //    Function:        query_effect
-    //
-    //    Description:    Returns the descriptor of the effect engine which index is
-    //          given as argument.
-    //          See effect_descriptor_t for details on effect descriptors.
-    //          This function together with EffectQueryNumberEffects() is used to enumerate all
-    //          effects present in the library. The enumeration sequence is:
-    //              EffectQueryNumberEffects(&num_effects);
-    //              for (i = 0; i < num_effects; i++)
-    //                  EffectQueryEffect(i,...);
-    //
-    //    Input/Output:
-    //          index:          index of the effect
-    //          pDescriptor:    address where to return the effect descriptor.
-    //
-    //    Output:
-    //        returned value:    0          successful operation.
-    //                          -ENODEV     library failed to initialize
-    //                          -EINVAL     invalid pDescriptor or index
-    //                          -ENOSYS     effect list has changed since last execution of
-    //                                      EffectQueryNumberEffects()
-    //                          -ENOENT     no more effect available
-    //        *pDescriptor:     updated with the effect descriptor.
-    //
-    ////////////////////////////////////////////////////////////////////////////////
-    int32_t (*query_effect)(uint32_t index,
-                            effect_descriptor_t *pDescriptor);
-
-    ////////////////////////////////////////////////////////////////////////////////
-    //
     //    Function:        create_effect
     //
     //    Description:    Creates an effect engine of the specified implementation uuid and
diff --git a/include/hardware/gralloc.h b/include/hardware/gralloc.h
index 7c819f0..a6d9c1f 100644
--- a/include/hardware/gralloc.h
+++ b/include/hardware/gralloc.h
@@ -57,9 +57,9 @@
     
     /* buffer is never written in software */
     GRALLOC_USAGE_SW_WRITE_NEVER        = 0x00000000,
-    /* buffer is never written in software */
+    /* buffer is rarely written in software */
     GRALLOC_USAGE_SW_WRITE_RARELY       = 0x00000020,
-    /* buffer is never written in software */
+    /* buffer is often written in software */
     GRALLOC_USAGE_SW_WRITE_OFTEN        = 0x00000030,
     /* mask for the software write values */
     GRALLOC_USAGE_SW_WRITE_MASK         = 0x000000F0,
diff --git a/include/hardware/sensors.h b/include/hardware/sensors.h
index af6bced..71a621c 100644
--- a/include/hardware/sensors.h
+++ b/include/hardware/sensors.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2008 The Android Open Source Project
+ * Copyright (C) 2012 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -26,6 +26,13 @@
 
 __BEGIN_DECLS
 
+/*****************************************************************************/
+
+#define SENSORS_HEADER_VERSION          1
+#define SENSORS_MODULE_API_VERSION_0_1  HARDWARE_MODULE_API_VERSION(0, 1)
+#define SENSORS_DEVICE_API_VERSION_0_1  HARDWARE_DEVICE_API_VERSION_2(0, 1, SENSORS_HEADER_VERSION)
+#define SENSORS_DEVICE_API_VERSION_1_0  HARDWARE_DEVICE_API_VERSION_2(1, 0, SENSORS_HEADER_VERSION)
+
 /**
  * The id of this module
  */
@@ -47,50 +54,35 @@
 #define SENSORS_HANDLE_COUNT            (1<<SENSORS_HANDLE_BITS)
 
 
-/**
- * Sensor types
+/* attributes queriable with query() */
+enum {
+    /*
+     * Availability: SENSORS_DEVICE_API_VERSION_1_0
+     * return the maximum number of events that can be returned
+     * in a single call to (*poll)(). This value is used by the
+     * framework to adequately dimension the buffer passed to
+     * (*poll)(), note that (*poll)() still needs to pay attention to
+     * the count parameter passed to it, it cannot blindly expect that
+     * this value will be used for all calls to (*poll)().
+     *
+     * Generally this value should be set to match the sum of the internal
+     * FIFOs of all available sensors.
+     */
+    SENSORS_QUERY_MAX_EVENTS_BATCH_COUNT     = 0
+};
+
+/*
+ * flags for (*batch)()
+ * Availability: SENSORS_DEVICE_API_VERSION_1_0
+ * see (*batch)() documentation for details
  */
-#define SENSOR_TYPE_ACCELEROMETER       1
-#define SENSOR_TYPE_MAGNETIC_FIELD      2
-#define SENSOR_TYPE_ORIENTATION         3
-#define SENSOR_TYPE_GYROSCOPE           4
-#define SENSOR_TYPE_LIGHT               5
-#define SENSOR_TYPE_PRESSURE            6
-#define SENSOR_TYPE_TEMPERATURE         7   // deprecated
-#define SENSOR_TYPE_PROXIMITY           8
-#define SENSOR_TYPE_GRAVITY             9
-#define SENSOR_TYPE_LINEAR_ACCELERATION 10
-#define SENSOR_TYPE_ROTATION_VECTOR     11
-#define SENSOR_TYPE_RELATIVE_HUMIDITY   12
-#define SENSOR_TYPE_AMBIENT_TEMPERATURE 13
+enum {
+    SENSORS_BATCH_DRY_RUN               = 0x00000001,
+    SENSORS_BATCH_WAKE_UPON_FIFO_FULL   = 0x00000002
+};
 
 /**
- * Values returned by the accelerometer in various locations in the universe.
- * all values are in SI units (m/s^2)
- */
-
-#define GRAVITY_SUN             (275.0f)
-#define GRAVITY_EARTH           (9.80665f)
-
-/** Maximum magnetic field on Earth's surface */
-#define MAGNETIC_FIELD_EARTH_MAX    (60.0f)
-
-/** Minimum magnetic field on Earth's surface */
-#define MAGNETIC_FIELD_EARTH_MIN    (30.0f)
-
-
-/**
- * status of each sensor
- */
-
-#define SENSOR_STATUS_UNRELIABLE        0
-#define SENSOR_STATUS_ACCURACY_LOW      1
-#define SENSOR_STATUS_ACCURACY_MEDIUM   2
-#define SENSOR_STATUS_ACCURACY_HIGH     3
-
-/**
- * Definition of the axis
- * ----------------------
+ * Definition of the axis used by the sensor HAL API
  *
  * This API is relative to the screen of the device in its default orientation,
  * that is, if the device can be used in portrait or landscape, this API
@@ -117,9 +109,142 @@
  *
  *    O: Origin (x=0,y=0,z=0)
  *
+ */
+
+/*
+ * Interaction with suspend mode
  *
+ * Unless otherwise noted, an enabled sensor shall not prevent the
+ * SoC to go into suspend mode. It is the responsibility of applications
+ * to keep a partial wake-lock should they wish to receive sensor
+ * events while the screen is off. While in suspend mode, and unless
+ * otherwise noted, enabled sensors' events are lost.
+ *
+ * Note that conceptually, the sensor itself is not de-activated while in
+ * suspend mode -- it's just that the data it returns are lost. As soon as
+ * the SoC gets out of suspend mode, operations resume as usual. Of course,
+ * in practice sensors shall be disabled while in suspend mode to
+ * save power, unless batch mode is active, in which case they must
+ * continue fill their internal FIFO (see the documentation of batch() to
+ * learn how suspend interacts with batch mode).
+ *
+ * In batch mode and only when the flag SENSORS_BATCH_WAKE_UPON_FIFO_FULL is
+ * set and supported, the specified sensor must be able to wake-up the SoC.
+ *
+ * There are notable exceptions to this behavior, which are sensor-dependent
+ * (see sensor types definitions below)
+ *
+ *
+ * The sensor type documentation below specifies the wake-up behavior of
+ * each sensor:
+ *   wake-up: yes     this sensor must wake-up the SoC to deliver events
+ *   wake-up: no      this sensor shall not wake-up the SoC, events are dropped
+ *
+ */
+
+/*
+ * Sensor type
+ *
+ * Each sensor has a type which defines what this sensor measures and how
+ * measures are reported. All types are defined below.
+ */
+
+/*
+ * Sensor fusion and virtual sensors
+ *
+ * Many sensor types are or can be implemented as virtual sensors from
+ * physical sensors on the device. For instance the rotation vector sensor,
+ * orientation sensor, pedometer, step-counter, etc...
+ *
+ * From the point of view of this API these virtual sensors MUST appear as
+ * real, individual sensors. It is the responsibility of the driver and HAL
+ * to make sure this is the case.
+ *
+ * In particular, all sensors must be able to function concurrently.
+ * For example, if defining both an accelerometer and a step counter,
+ * then both must be able to work concurrently.
+ */
+
+/*
+ * Trigger modes
+ *
+ * Sensors can report events in different ways called trigger modes,
+ * each sensor type has one and only one trigger mode associated to it.
+ * Currently there are four trigger modes defined:
+ *
+ * continuous: events are reported at a constant rate defined by setDelay().
+ *             eg: accelerometers, gyroscopes.
+ * on-change:  events are reported only if the sensor's value has changed.
+ *             setDelay() is used to set a lower limit to the reporting
+ *             period (minimum time between two events).
+ *             The HAL must return an event immediately when an on-change
+ *             sensor is activated.
+ *             eg: proximity, light sensors
+ * one-shot:   a single event is reported and the sensor returns to the
+ *             disabled state, no further events are reported. setDelay() is
+ *             ignored.
+ *             eg: significant motion sensor
+ * special:    see details in the sensor type specification below
+ *
+ */
+
+/*
+ * SENSOR_TYPE_ACCELEROMETER
+ * trigger-mode: continuous
+ * wake-up sensor: no
+ *
+ *  All values are in SI units (m/s^2) and measure the acceleration of the
+ *  device minus the force of gravity.
+ *
+ *  Acceleration sensors return sensor events for all 3 axes at a constant
+ *  rate defined by setDelay().
+ *
+ *  x: Acceleration on the x-axis
+ *  y: Acceleration on the y-axis
+ *  z: Acceleration on the z-axis
+ *
+ * Note that the readings from the accelerometer include the acceleration
+ * due to gravity (which is opposite to the direction of the gravity vector).
+ *
+ *  Examples:
+ *    The norm of <x, y, z>  should be close to 0 when in free fall.
+ *
+ *    When the device lies flat on a table and is pushed on its left side
+ *    toward the right, the x acceleration value is positive.
+ *
+ *    When the device lies flat on a table, the acceleration value is +9.81,
+ *    which correspond to the acceleration of the device (0 m/s^2) minus the
+ *    force of gravity (-9.81 m/s^2).
+ *
+ *    When the device lies flat on a table and is pushed toward the sky, the
+ *    acceleration value is greater than +9.81, which correspond to the
+ *    acceleration of the device (+A m/s^2) minus the force of
+ *    gravity (-9.81 m/s^2).
+ */
+#define SENSOR_TYPE_ACCELEROMETER                    (1)
+
+/*
+ * SENSOR_TYPE_GEOMAGNETIC_FIELD
+ * trigger-mode: continuous
+ * wake-up sensor: no
+ *
+ *  All values are in micro-Tesla (uT) and measure the geomagnetic
+ *  field in the X, Y and Z axis.
+ *
+ *  Returned values include calibration mechanisms such that the vector is
+ *  aligned with the magnetic declination and heading of the earth's
+ *  geomagnetic field.
+ *
+ *  Magnetic Field sensors return sensor events for all 3 axes at a constant
+ *  rate defined by setDelay().
+ */
+#define SENSOR_TYPE_GEOMAGNETIC_FIELD                (2)
+#define SENSOR_TYPE_MAGNETIC_FIELD  SENSOR_TYPE_GEOMAGNETIC_FIELD
+
+/*
  * SENSOR_TYPE_ORIENTATION
- * -----------------------
+ * trigger-mode: continuous
+ * wake-up sensor: no
  * 
  * All values are angles in degrees.
  * 
@@ -153,46 +278,13 @@
  *
  * Note: This definition is different from yaw, pitch and roll used in aviation
  *  where the X axis is along the long side of the plane (tail to nose).
- *  
- *  
- * SENSOR_TYPE_ACCELEROMETER
- * -------------------------
- *
- *  All values are in SI units (m/s^2) and measure the acceleration of the
- *  device minus the force of gravity.
- *  
- *  Acceleration sensors return sensor events for all 3 axes at a constant
- *  rate defined by setDelay().
- *
- *  x: Acceleration minus Gx on the x-axis 
- *  y: Acceleration minus Gy on the y-axis 
- *  z: Acceleration minus Gz on the z-axis
- *  
- *  Examples:
- *    When the device lies flat on a table and is pushed on its left side
- *    toward the right, the x acceleration value is positive.
- *    
- *    When the device lies flat on a table, the acceleration value is +9.81,
- *    which correspond to the acceleration of the device (0 m/s^2) minus the
- *    force of gravity (-9.81 m/s^2).
- *    
- *    When the device lies flat on a table and is pushed toward the sky, the
- *    acceleration value is greater than +9.81, which correspond to the
- *    acceleration of the device (+A m/s^2) minus the force of 
- *    gravity (-9.81 m/s^2).
- *    
- *    
- * SENSOR_TYPE_MAGNETIC_FIELD
- * --------------------------
- * 
- *  All values are in micro-Tesla (uT) and measure the ambient magnetic
- *  field in the X, Y and Z axis.
- *
- *  Magnetic Field sensors return sensor events for all 3 axes at a constant
- *  rate defined by setDelay().
- *
+ */
+#define SENSOR_TYPE_ORIENTATION                      (3)
+
+/*
  * SENSOR_TYPE_GYROSCOPE
- * ---------------------
+ * trigger-mode: continuous
+ * wake-up sensor: no
  *
  *  All values are in radians/second and measure the rate of rotation
  *  around the X, Y and Z axis.  The coordinate system is the same as is
@@ -205,52 +297,78 @@
  *  with the definition of roll given earlier.
  *  The range should at least be 17.45 rad/s (ie: ~1000 deg/s).
  *
+ *  automatic gyro-drift compensation is allowed but not required.
+ */
+#define SENSOR_TYPE_GYROSCOPE                        (4)
+
+/*
+ * SENSOR_TYPE_LIGHT
+ * trigger-mode: on-change
+ * wake-up sensor: no
+ *
+ * The light sensor value is returned in SI lux units.
+ */
+#define SENSOR_TYPE_LIGHT                            (5)
+
+/*
+ * SENSOR_TYPE_PRESSURE
+ * trigger-mode: continuous
+ * wake-up sensor: no
+ *
+ * The pressure sensor return the athmospheric pressure in hectopascal (hPa)
+ */
+#define SENSOR_TYPE_PRESSURE                         (6)
+
+/* SENSOR_TYPE_TEMPERATURE is deprecated in the HAL */
+#define SENSOR_TYPE_TEMPERATURE                      (7)
+
+/*
  * SENSOR_TYPE_PROXIMITY
- * ----------------------
+ * trigger-mode: on-change
+ * wake-up sensor: yes
  *
  * The distance value is measured in centimeters.  Note that some proximity
  * sensors only support a binary "close" or "far" measurement.  In this case,
  * the sensor should report its maxRange value in the "far" state and a value
  * less than maxRange in the "near" state.
- *
- * Proximity sensors report a value only when it changes and each time the
- * sensor is enabled.
- *
- * SENSOR_TYPE_LIGHT
- * -----------------
- *
- * The light sensor value is returned in SI lux units.
- *
- * Light sensors report a value only when it changes and each time the
- * sensor is enabled.
- *
- * SENSOR_TYPE_PRESSURE
- * --------------------
- *
- * The pressure sensor return the athmospheric pressure in hectopascal (hPa)
- *
- * Pressure sensors report events at a constant rate defined by setDelay().
- *
+ */
+#define SENSOR_TYPE_PROXIMITY                        (8)
+
+/*
  * SENSOR_TYPE_GRAVITY
- * -------------------
+ * trigger-mode: continuous
+ * wake-up sensor: no
  *
  * A gravity output indicates the direction of and magnitude of gravity in
  * the devices's coordinates.  On Earth, the magnitude is 9.8 m/s^2.
  * Units are m/s^2.  The coordinate system is the same as is used for the
  * acceleration sensor. When the device is at rest, the output of the
  * gravity sensor should be identical to that of the accelerometer.
- *
+ */
+#define SENSOR_TYPE_GRAVITY                          (9)
+
+/*
  * SENSOR_TYPE_LINEAR_ACCELERATION
- * --------------------------------
+ * trigger-mode: continuous
+ * wake-up sensor: no
  *
  * Indicates the linear acceleration of the device in device coordinates,
  * not including gravity.
- * This output is essentially Acceleration - Gravity.  Units are m/s^2.
+ *
+ * The output is conceptually:
+ *    output of TYPE_ACCELERATION - output of TYPE_GRAVITY
+ *
+ * Readings on all axes should be close to 0 when device lies on a table.
+ * Units are m/s^2.
  * The coordinate system is the same as is used for the acceleration sensor.
- *
- *
+ */
+#define SENSOR_TYPE_LINEAR_ACCELERATION             (10)
+
+
+/*
  * SENSOR_TYPE_ROTATION_VECTOR
- * ---------------------------
+ * trigger-mode: continuous
+ * wake-up sensor: no
  *
  * A rotation vector represents the orientation of the device as a combination
  * of an angle and an axis, in which the device has rotated through an angle
@@ -281,28 +399,230 @@
  *   sensors_event_t.data[1] = y*sin(theta/2)
  *   sensors_event_t.data[2] = z*sin(theta/2)
  *   sensors_event_t.data[3] =   cos(theta/2)
- *
- *
+ */
+#define SENSOR_TYPE_ROTATION_VECTOR                 (11)
+
+/*
  * SENSOR_TYPE_RELATIVE_HUMIDITY
- * ------------------------------
+ * trigger-mode: on-change
+ * wake-up sensor: no
  *
  * A relative humidity sensor measures relative ambient air humidity and
  * returns a value in percent.
- *
- * Relative humidity sensors report a value only when it changes and each
- * time the sensor is enabled.
- *
- *
+ */
+#define SENSOR_TYPE_RELATIVE_HUMIDITY               (12)
+
+/*
  * SENSOR_TYPE_AMBIENT_TEMPERATURE
- * -------------------------------
+ * trigger-mode: on-change
+ * wake-up sensor: no
  *
  * The ambient (room) temperature in degree Celsius.
+ */
+#define SENSOR_TYPE_AMBIENT_TEMPERATURE             (13)
+
+/*
+ * SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED
+ * trigger-mode: continuous
+ * wake-up sensor: no
  *
- * Temperature sensors report a value only when it changes and each time the
- * sensor is enabled.
+ *  All values are in micro-Tesla (uT) and measure the ambient magnetic
+ *  field in the X, Y and Z axis.
  *
+ *  No periodic calibration is performed (ie: there are no discontinuities
+ *  in the data stream while using this sensor). Assumptions that the the
+ *  magnetic field is due to the Earth's poles should be avoided.
+ *
+ *  Factory calibration and temperature compensation should still be applied.
+ */
+#define SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED     (14)
+
+/*
+ * SENSOR_TYPE_GAME_ROTATION_VECTOR
+ * trigger-mode: continuous
+ * wake-up sensor: no
+ *
+ * SENSOR_TYPE_GAME_ROTATION_VECTOR is identical to SENSOR_TYPE_ROTATION_VECTOR,
+ * except that it doesn't use the geomagnetic field. Therefore the Y axis doesn't
+ * point north, but instead to some other reference, that reference is allowed
+ * to drift by the same order of magnitude than the gyroscope drift around
+ * the Z axis.
+ *
+ * In the ideal case, a phone rotated and returning to the same real-world
+ * orientation should report the same game rotation vector
+ * (without using the earth's geomagnetic field).
+ *
+ * see SENSOR_TYPE_ROTATION_VECTOR for more details
+ */
+#define SENSOR_TYPE_GAME_ROTATION_VECTOR            (15)
+
+/*
+ * SENSOR_TYPE_GYROSCOPE_UNCALIBRATED
+ * trigger-mode: continuous
+ * wake-up sensor: no
+ *
+ *  All values are in radians/second and measure the rate of rotation
+ *  around the X, Y and Z axis.  The coordinate system is the same as is
+ *  used for the acceleration sensor. Rotation is positive in the
+ *  counter-clockwise direction (right-hand rule). That is, an observer
+ *  looking from some positive location on the x, y or z axis at a device
+ *  positioned on the origin would report positive rotation if the device
+ *  appeared to be rotating counter clockwise. Note that this is the
+ *  standard mathematical definition of positive rotation and does not agree
+ *  with the definition of roll given earlier.
+ *  The range should at least be 17.45 rad/s (ie: ~1000 deg/s).
+ *
+ *  No gyro-drift compensation shall be performed.
+ *  Factory calibration and temperature compensation should still be applied.
+ */
+#define SENSOR_TYPE_GYROSCOPE_UNCALIBRATED          (16)
+
+
+/*
+ * SENSOR_TYPE_SIGNIFICANT_MOTION
+ * trigger-mode: one-shot
+ * wake-up sensor: yes
+ *
+ * A sensor of this type triggers an event each time significant motion
+ * is detected and automatically disables itself.
+ * The only allowed value to return is 1.0.
+ *
+ *
+ * TODO: give more details about what constitute significant motion
+ *       and/or what algorithm is to be used
+ *
+ *
+ *  IMPORTANT NOTE: this sensor type is very different from other types
+ *  in that it must work when the screen is off without the need of
+ *  holding a partial wake-lock and MUST allow the SoC to go into suspend.
+ *  When significant motion is detected, the sensor must awaken the SoC and
+ *  the event be reported.
+ *
+ *  If a particular hardware cannot support this mode of operation then this
+ *  sensor type MUST NOT be reported by the HAL. ie: it is not acceptable
+ *  to "emulate" this sensor in the HAL.
+ *
+ *  The whole point of this sensor type is to save power by keeping the
+ *  SoC in suspend mode when the device is at rest.
+ *
+ *  When the sensor is not activated, it must also be deactivated in the
+ *  hardware: it must not wake up the SoC anymore, even in case of
+ *  significant motion.
+ *
+ *  setDelay() has no effect and is ignored.
+ *  Once a "significant motion" event is returned, a sensor of this type
+ *  must disables itself automatically, as if activate(..., 0) had been called.
  */
 
+#define SENSOR_TYPE_SIGNIFICANT_MOTION              (17)
+
+
+/*
+ * SENSOR_TYPE_PEDOMETER
+ * trigger-mode: special
+ * wake-up sensor: no
+ *
+ * A sensor of this type triggers an event each time a step is taken
+ * by the user. The only allowed value to return is 1.0 and an event is
+ * generated for each step. Like with any other event, the timestamp
+ * indicates when the event (here the step) occurred, this corresponds to when
+ * the foot hit the ground, generating a high variation in acceleration.
+ *
+ * While this sensor operates, it shall not disrupt any other sensors, in
+ * particular, but not limited to, the accelerometer; which might very well
+ * be in use as well.
+ *
+ * This sensor must be low power. That is, if the step detection cannot be
+ * done in hardware, this sensor should not be defined. Also, when the
+ * pedometer is activated and the accelerometer is not, only steps should
+ * trigger interrupts (not accelerometer data).
+ *
+ * setDelay() has no impact on this sensor type
+ */
+
+#define SENSOR_TYPE_PEDOMETER                       (18)
+
+
+/*
+ * SENSOR_TYPE_STEP_COUNTER
+ * trigger-mode: on-change
+ * wake-up sensor: no
+ *
+ * A sensor of this type returns the number of steps taken by the user since
+ * the last reboot. The value is returned as a uint64_t and is reset to
+ * zero only on a system reboot.
+ *
+ * The timestamp of the event is set to the time when the first step
+ * for that event was taken.
+ * See SENSOR_TYPE_PEDOMETER for the signification of the time of a step.
+ *
+ *  The minimum size of the hardware's internal counter shall be 16 bits
+ *  (this restriction is here to avoid too frequent wake-ups when the
+ *  delay is very large).
+ *
+ *  IMPORTANT NOTE: this sensor type is different from other types
+ *  in that it must work when the screen is off without the need of
+ *  holding a partial wake-lock and MUST allow the SoC to go into suspend.
+ *  Unlike other sensors, while in suspend mode this sensor must stay active,
+ *  no events are reported during that time but, steps continue to be
+ *  accounted for; an event will be reported as soon as the SoC resumes if
+ *  the timeout has expired.
+ *
+ *    In other words, when the screen is off and the device allowed to
+ *    go into suspend mode, we don't want to be woken up, regardless of the
+ *    setDelay() value, but the steps shall continue to be counted.
+ *
+ *    The driver must however ensure that the internal step count never
+ *    overflows. It is allowed in this situation to wake the SoC up so the
+ *    driver can do the counter maintenance.
+ *
+ *  While this sensor operates, it shall not disrupt any other sensors, in
+ *  particular, but not limited to, the accelerometer; which might very well
+ *  be in use as well.
+ *
+ *  If a particular hardware cannot support these modes of operation then this
+ *  sensor type MUST NOT be reported by the HAL. ie: it is not acceptable
+ *  to "emulate" this sensor in the HAL.
+ *
+ * This sensor must be low power. That is, if the step detection cannot be
+ * done in hardware, this sensor should not be defined. Also, when the
+ * step counter is activated and the accelerometer is not, only steps should
+ * trigger interrupts (not accelerometer data).
+ *
+ *  The whole point of this sensor type is to save power by keeping the
+ *  SoC in suspend mode when the device is at rest.
+ */
+
+#define SENSOR_TYPE_STEP_COUNTER                    (19)
+
+
+/**
+ * Values returned by the accelerometer in various locations in the universe.
+ * all values are in SI units (m/s^2)
+ */
+#define GRAVITY_SUN             (275.0f)
+#define GRAVITY_EARTH           (9.80665f)
+
+/** Maximum magnetic field on Earth's surface */
+#define MAGNETIC_FIELD_EARTH_MAX    (60.0f)
+
+/** Minimum magnetic field on Earth's surface */
+#define MAGNETIC_FIELD_EARTH_MIN    (30.0f)
+
+
+/**
+ * status of orientation sensor
+ */
+
+#define SENSOR_STATUS_UNRELIABLE        0
+#define SENSOR_STATUS_ACCURACY_LOW      1
+#define SENSOR_STATUS_ACCURACY_MEDIUM   2
+#define SENSOR_STATUS_ACCURACY_HIGH     3
+
+
+/**
+ * sensor event data
+ */
 typedef struct {
     union {
         float v[3];
@@ -370,6 +690,9 @@
 
         /* relative humidity in percent */
         float           relative_humidity;
+
+        /* step-counter */
+        uint64_t        step_counter;
     };
     uint32_t        reserved1[4];
 } sensors_event_t;
@@ -395,79 +718,239 @@
 };
 
 struct sensor_t {
-    /* name of this sensors */
+    /* name of this sensor */
     const char*     name;
+
     /* vendor of the hardware part */
     const char*     vendor;
+
     /* version of the hardware part + driver. The value of this field
      * must increase when the driver is updated in a way that changes the
      * output of this sensor. This is important for fused sensors when the
      * fusion algorithm is updated.
      */    
     int             version;
-    /* handle that identifies this sensors. This handle is used to activate
-     * and deactivate this sensor. The value of the handle must be 8 bits
-     * in this version of the API. 
+
+    /* handle that identifies this sensors. This handle is used to reference
+     * this sensor throughout the HAL API.
      */
     int             handle;
+
     /* this sensor's type. */
     int             type;
-    /* maximaum range of this sensor's value in SI units */
+
+    /* maximum range of this sensor's value in SI units */
     float           maxRange;
+
     /* smallest difference between two values reported by this sensor */
     float           resolution;
+
     /* rough estimate of this sensor's power consumption in mA */
     float           power;
-    /* minimum delay allowed between events in microseconds. A value of zero
-     * means that this sensor doesn't report events at a constant rate, but
-     * rather only when a new data is available */
+
+    /* this value depends on the trigger mode:
+     *
+     *   continuous: minimum sample period allowed in microseconds
+     *   on-change : 0
+     *   one-shot  :-1
+     *   special   : 0, unless otherwise noted
+     */
     int32_t         minDelay;
+
     /* reserved fields, must be zero */
     void*           reserved[8];
 };
 
 
-/**
- * Every device data structure must begin with hw_device_t
- * followed by module specific public methods and attributes.
+/*
+ * sensors_poll_device_t is used with SENSORS_DEVICE_API_VERSION_0_1
+ * and is present for backward binary and source compatibility.
+ * (see documentation of the hooks in struct sensors_poll_device_1 below)
  */
 struct sensors_poll_device_t {
     struct hw_device_t common;
-
-    /** Activate/deactivate one sensor.
-     *
-     * @param handle is the handle of the sensor to change.
-     * @param enabled set to 1 to enable, or 0 to disable the sensor.
-     *
-     * @return 0 on success, negative errno code otherwise
-     */
     int (*activate)(struct sensors_poll_device_t *dev,
             int handle, int enabled);
-
-    /**
-     * Set the delay between sensor events in nanoseconds for a given sensor.
-     *
-     * If the requested value is less than sensor_t::minDelay, then it's
-     * silently clamped to sensor_t::minDelay unless sensor_t::minDelay is
-     * 0, in which case it is clamped to >= 1ms.
-     *
-     * @return 0 if successful, < 0 on error
-     */
     int (*setDelay)(struct sensors_poll_device_t *dev,
             int handle, int64_t ns);
-
-    /**
-     * Returns an array of sensor data.
-     * This function must block until events are available.
-     *
-     * @return the number of events read on success, or -errno in case of an error.
-     * This function should never return 0 (no event).
-     *
-     */
     int (*poll)(struct sensors_poll_device_t *dev,
             sensors_event_t* data, int count);
 };
 
+/*
+ * struct sensors_poll_device_1 is used with SENSORS_DEVICE_API_VERSION_1_0
+ */
+typedef struct sensors_poll_device_1 {
+    union {
+        /* sensors_poll_device_1 is compatible with sensors_poll_device_t,
+         * and can be down-cast to it
+         */
+        struct sensors_poll_device_t v0;
+
+        struct {
+            struct hw_device_t common;
+
+            /* Activate/de-activate one sensor.
+             *
+             * handle is the handle of the sensor to change.
+             * enabled set to 1 to enable, or 0 to disable the sensor.
+             *
+             * unless otherwise noted in the sensor types definitions, an
+             * activated sensor never prevents the SoC to go into suspend
+             * mode; that is, the HAL shall not hold a partial wake-lock on
+             * behalf of applications.
+             *
+             * one-shot sensors de-activate themselves automatically upon
+             * receiving an event and they must still accept to be deactivated
+             * through a call to activate(..., ..., 0).
+             *
+             * if "enabled" is true and the sensor is already activated, this
+             * function is a no-op and succeeds.
+             *
+             * if "enabled" is false and the sensor is already de-activated,
+             * this function is a no-op and succeeds.
+             *
+             * return 0 on success, negative errno code otherwise
+             */
+            int (*activate)(struct sensors_poll_device_t *dev,
+                    int handle, int enabled);
+
+            /**
+             * Set the delay between sensor events in nanoseconds for a given sensor.
+             *
+             * What the delay parameter means depends on the specified
+             * sensor's trigger mode:
+             *
+             * continuous: setDelay() sets the sampling rate.
+             * on-change: setDelay() limits the delivery rate of events
+             * one-shot: setDelay() is ignored. it has no effect.
+             * special: see specific sensor type definitions
+             *
+             * For continuous and on-change sensors, if the requested value is
+             * less than sensor_t::minDelay, then it's silently clamped to
+             * sensor_t::minDelay unless sensor_t::minDelay is 0, in which
+             * case it is clamped to >= 1ms.
+             *
+             * @return 0 if successful, < 0 on error
+             */
+            int (*setDelay)(struct sensors_poll_device_t *dev,
+                    int handle, int64_t ns);
+
+            /**
+             * Returns an array of sensor data.
+             * This function must block until events are available.
+             *
+             * return the number of events read on success, or -errno in case
+             * of an error.
+             *
+             * The number of events returned in data must be less or equal
+             * to SENSORS_QUERY_MAX_EVENTS_BATCH_COUNT.
+             *
+             * This function shall never return 0 (no event).
+             */
+            int (*poll)(struct sensors_poll_device_t *dev,
+                    sensors_event_t* data, int count);
+        };
+    };
+
+    /*
+     * Used to retrieve information about the sensor HAL
+     *
+     * Returns 0 on success or -errno on error.
+     */
+    int (*query)(struct sensors_poll_device_1* dev, int what, int* value);
+
+
+    /*
+     * Enables batch mode for the given sensor.
+     *
+     * A timeout value of zero disables batch mode for the given sensor.
+     *
+     * While in batch mode sensor events are reported in batches at least
+     * every "timeout" nanosecond; that is all events since the previous batch
+     * are recorded and returned all at once. Batches can be interleaved and
+     * split, and as usual events of the same sensor type are time-ordered.
+     *
+     * setDelay() is not affected and it behaves as usual.
+     *
+     * Each event has a timestamp associated with it, the timestamp
+     * must be accurate and correspond to the time at which the event
+     * physically happened.
+     *
+     * If internal h/w FIFOs fill-up before the timeout, then events are
+     * reported at that point. No event shall be dropped or lost,
+     *
+     * By default batch mode doesn't significantly change the interaction with
+     * suspend mode, that is, sensors must continue to allow the SoC to
+     * go into suspend mode and sensors must stay active to fill their
+     * internal FIFO, in this mode, when the FIFO fills-up, it shall wrap
+     * around (basically behave like a circular buffer, overwriting events).
+     * As soon as the SoC comes out of suspend mode, a batch is produced with
+     * as much as the recent history as possible, and batch operation
+     * resumes as usual.
+     *
+     * The behavior described above allows applications to record the recent
+     * history of a set of sensor while keeping the SoC into suspend. It
+     * also allows the hardware to not have to rely on a wake-up interrupt line.
+     *
+     * There are cases however where an application cannot afford to lose
+     * any events, even when the device goes into suspend mode. The behavior
+     * specified above can be altered by setting the
+     * SENSORS_BATCH_WAKE_UPON_FIFO_FULL flag. If this flag is set, the SoC
+     * must be woken up from suspend and a batch must be returned before
+     * the FIFO fills-up. Enough head room must be allocated in the FIFO to allow
+     * the device to entirely come out of suspend (which might take a while and
+     * is device dependent) such that no event are lost.
+     *
+     *   If the hardware cannot support this mode, or, if the physical
+     *   FIFO is so small that the device would never be allowed to go into
+     *   suspend for long enough (typically 4 to 10 seconds), then this
+     *   function MUST fail when the flag SENSORS_BATCH_WAKE_UPON_FIFO_FULL
+     *   is set.
+     *
+     *
+     * If the flag SENSORS_BATCH_DRY_RUN is set, this function returns
+     * without modifying the batch mode and has no side effects, but returns
+     * errors as usual (as it would if this flag was not set). This flag
+     * is used to check if batch mode is available for a given configuration.
+     *
+     * Return values:
+     *
+     * If successful, 0 is returned.
+     * If the specified sensor doesn't support batch mode, -EINVAL is returned.
+     * If the specified sensor's trigger-mode is one-shot, -EINVAL is returned.
+     * If any of the constraint above cannot be satisfied, -EINVAL is returned.
+     *
+     * If timeout is set to 0, this function must succeed.
+     *
+     *
+     * IMPLEMENTATION NOTES:
+     *
+     * batch mode, if supported, should happen at the hardware level,
+     * typically using hardware FIFOs. In particular, it SHALL NOT be
+     * implemented in the HAL, as this would be counter productive.
+     * The goal here is to save significant amounts of power.
+     *
+     * In SENSORS_BATCH_WAKE_UPON_FIFO_FULL, if the hardware has a
+     * limited FIFO size that wouldn't permit significant savings
+     * (typical on some gyroscopes), because it wouldn't allow the SoC to go
+     * into suspend mode for enough time, then it is imperative to NOT SUPPORT
+     * batch mode for that sensor.
+     *
+     * batch mode can be enabled or disabled at any time, in particular
+     * while the specified sensor is already enabled and this shall not
+     * result in the loss of events.
+     *
+     */
+    int (*batch)(struct sensors_poll_device_1* dev,
+            int handle, int flags, int64_t timeout);
+
+    void (*reserved_procs[8])(void);
+
+} sensors_poll_device_1_t;
+
+
+
 /** convenience API for opening and closing a device */
 
 static inline int sensors_open(const struct hw_module_t* module,
@@ -480,6 +963,16 @@
     return device->common.close(&device->common);
 }
 
+static inline int sensors_open_1(const struct hw_module_t* module,
+        sensors_poll_device_1_t** device) {
+    return module->methods->open(module,
+            SENSORS_HARDWARE_POLL, (struct hw_device_t**)device);
+}
+
+static inline int sensors_close_1(sensors_poll_device_1_t* device) {
+    return device->common.close(&device->common);
+}
+
 __END_DECLS
 
 #endif  // ANDROID_SENSORS_INTERFACE_H
diff --git a/modules/Android.mk b/modules/Android.mk
index faa8bb3..486b42d 100644
--- a/modules/Android.mk
+++ b/modules/Android.mk
@@ -1,2 +1,2 @@
-hardware_modules := gralloc hwcomposer audio nfc nfc-nci local_time power usbaudio audio_remote_submix
+hardware_modules := gralloc hwcomposer audio nfc nfc-nci local_time power usbaudio audio_remote_submix camera
 include $(call all-named-subdir-makefiles,$(hardware_modules))
diff --git a/modules/audio_remote_submix/audio_hw.cpp b/modules/audio_remote_submix/audio_hw.cpp
index 3756274..5e88ef7 100755
--- a/modules/audio_remote_submix/audio_hw.cpp
+++ b/modules/audio_remote_submix/audio_hw.cpp
@@ -186,18 +186,16 @@
 
         pthread_mutex_lock(&out->dev->lock);
 
-        MonoPipe* sink = out->dev->rsxSink.get();
-        if (sink != NULL) {
-            sink->incStrong(out);
-        } else {
-            pthread_mutex_unlock(&out->dev->lock);
-            return 0;
-        }
+        { // using the sink
+            sp<MonoPipe> sink = out->dev->rsxSink.get();
+            if (sink == 0) {
+                pthread_mutex_unlock(&out->dev->lock);
+                return 0;
+            }
 
-        ALOGI("shutdown");
-        sink->shutdown(true);
-
-        sink->decStrong(out);
+            ALOGI("shutdown");
+            sink->shutdown(true);
+        } // done using the sink
 
         pthread_mutex_unlock(&out->dev->lock);
     }
@@ -240,16 +238,16 @@
 
     out->dev->output_standby = false;
 
-    MonoPipe* sink = out->dev->rsxSink.get();
-    if (sink != NULL) {
+    sp<MonoPipe> sink = out->dev->rsxSink.get();
+    if (sink != 0) {
         if (sink->isShutdown()) {
+            sink.clear();
             pthread_mutex_unlock(&out->dev->lock);
             // the pipe has already been shutdown, this buffer will be lost but we must
             //   simulate timing so we don't drain the output faster than realtime
             usleep(frames * 1000000 / out_get_sample_rate(&stream->common));
             return bytes;
         }
-        sink->incStrong(buffer);
     } else {
         pthread_mutex_unlock(&out->dev->lock);
         ALOGE("out_write without a pipe!");
@@ -260,12 +258,13 @@
     pthread_mutex_unlock(&out->dev->lock);
 
     written_frames = sink->write(buffer, frames);
+
     if (written_frames < 0) {
         if (written_frames == (ssize_t)NEGOTIATE) {
             ALOGE("out_write() write to pipe returned NEGOTIATE");
 
             pthread_mutex_lock(&out->dev->lock);
-            sink->decStrong(buffer);
+            sink.clear();
             pthread_mutex_unlock(&out->dev->lock);
 
             written_frames = 0;
@@ -278,9 +277,7 @@
     }
 
     pthread_mutex_lock(&out->dev->lock);
-
-    sink->decStrong(buffer);
-
+    sink.clear();
     pthread_mutex_unlock(&out->dev->lock);
 
     if (written_frames < 0) {
@@ -414,45 +411,43 @@
     }
 
     in->read_counter_frames += frames_to_read;
-
-    MonoPipeReader* source = in->dev->rsxSource.get();
-    if (source != NULL) {
-        source->incStrong(buffer);
-    } else {
-        ALOGE("no audio pipe yet we're trying to read!");
-        pthread_mutex_unlock(&in->dev->lock);
-        usleep((bytes / frame_size) * 1000000 / in_get_sample_rate(&stream->common));
-        memset(buffer, 0, bytes);
-        return bytes;
-    }
-
-    pthread_mutex_unlock(&in->dev->lock);
-
-    // read the data from the pipe (it's non blocking)
     size_t remaining_frames = frames_to_read;
-    int attempts = 0;
-    char* buff = (char*)buffer;
-    while ((remaining_frames > 0) && (attempts < MAX_READ_ATTEMPTS)) {
-        attempts++;
-        frames_read = source->read(buff, remaining_frames, AudioBufferProvider::kInvalidPTS);
-        if (frames_read > 0) {
-            remaining_frames -= frames_read;
-            buff += frames_read * frame_size;
-            //ALOGV("  in_read (att=%d) got %ld frames, remaining=%u",
-            //      attempts, frames_read, remaining_frames);
-        } else {
-            //ALOGE("  in_read read returned %ld", frames_read);
-            usleep(READ_ATTEMPT_SLEEP_MS * 1000);
+
+    {
+        // about to read from audio source
+        sp<MonoPipeReader> source = in->dev->rsxSource.get();
+        if (source == 0) {
+            ALOGE("no audio pipe yet we're trying to read!");
+            pthread_mutex_unlock(&in->dev->lock);
+            usleep((bytes / frame_size) * 1000000 / in_get_sample_rate(&stream->common));
+            memset(buffer, 0, bytes);
+            return bytes;
         }
+
+        pthread_mutex_unlock(&in->dev->lock);
+
+        // read the data from the pipe (it's non blocking)
+        int attempts = 0;
+        char* buff = (char*)buffer;
+        while ((remaining_frames > 0) && (attempts < MAX_READ_ATTEMPTS)) {
+            attempts++;
+            frames_read = source->read(buff, remaining_frames, AudioBufferProvider::kInvalidPTS);
+            if (frames_read > 0) {
+                remaining_frames -= frames_read;
+                buff += frames_read * frame_size;
+                //ALOGV("  in_read (att=%d) got %ld frames, remaining=%u",
+                //      attempts, frames_read, remaining_frames);
+            } else {
+                //ALOGE("  in_read read returned %ld", frames_read);
+                usleep(READ_ATTEMPT_SLEEP_MS * 1000);
+            }
+        }
+        // done using the source
+        pthread_mutex_lock(&in->dev->lock);
+        source.clear();
+        pthread_mutex_unlock(&in->dev->lock);
     }
 
-    // done using the source
-    pthread_mutex_lock(&in->dev->lock);
-
-    source->decStrong(buffer);
-
-    pthread_mutex_unlock(&in->dev->lock);
-
     if (remaining_frames > 0) {
         ALOGV("  remaining_frames = %d", remaining_frames);
         memset(((char*)buffer)+ bytes - (remaining_frames * frame_size), 0,
@@ -571,8 +566,7 @@
     // initialize pipe
     {
         ALOGV("  initializing pipe");
-        const NBAIO_Format format =
-                config->sample_rate == 48000 ? Format_SR48_C2_I16 : Format_SR44_1_C2_I16;
+        const NBAIO_Format format = Format_from_SR_C(config->sample_rate, 2);
         const NBAIO_Format offers[1] = {format};
         size_t numCounterOffers = 0;
         // creating a MonoPipe with optional blocking set to true.
diff --git a/modules/camera/Android.mk b/modules/camera/Android.mk
new file mode 100644
index 0000000..44d7212
--- /dev/null
+++ b/modules/camera/Android.mk
@@ -0,0 +1,39 @@
+# Copyright (C) 2012 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := camera.default
+LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
+
+LOCAL_C_INCLUDES += \
+	system/core/include \
+	system/media/camera/include \
+
+LOCAL_SRC_FILES := \
+	CameraHAL.cpp \
+	Camera.cpp \
+
+LOCAL_SHARED_LIBRARIES := \
+	libcamera_metadata \
+	libcutils \
+	liblog \
+
+LOCAL_CFLAGS += -Wall -Wextra
+
+LOCAL_MODULE_TAGS := optional
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/modules/camera/Camera.cpp b/modules/camera/Camera.cpp
new file mode 100644
index 0000000..6ae0a5d
--- /dev/null
+++ b/modules/camera/Camera.cpp
@@ -0,0 +1,132 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cstdlib>
+#include <pthread.h>
+
+//#define LOG_NDEBUG 0
+#define LOG_TAG "Camera"
+#include <cutils/log.h>
+
+#define ATRACE_TAG (ATRACE_TAG_CAMERA | ATRACE_TAG_HAL)
+#include <cutils/trace.h>
+
+#include "Camera.h"
+
+namespace default_camera_hal {
+
+extern "C" {
+// Shim passed to the framework to close an opened device.
+static int close_device(hw_device_t* dev)
+{
+    camera2_device_t* cam_dev = reinterpret_cast<camera2_device_t*>(dev);
+    Camera* cam = static_cast<Camera*>(cam_dev->priv);
+    return cam->close();
+}
+} // extern "C"
+
+Camera::Camera(int id, const hw_module_t* module)
+    : mId(id),
+      mBusy(false),
+      mMetadata(NULL)
+{
+    pthread_mutex_init(&mMutex,
+                       NULL); // No pthread mutex attributes.
+
+    // TODO: fill in device operations function pointers
+    mDevice.common.tag    = HARDWARE_DEVICE_TAG;
+    mDevice.common.module = const_cast<hw_module_t*>(module);
+    mDevice.common.close  = close_device;
+    mDevice.priv          = this;
+}
+
+Camera::~Camera()
+{
+}
+
+int Camera::open()
+{
+    ALOGV("%s: camera id %d", __func__, mId);
+    ATRACE_BEGIN("open");
+    pthread_mutex_lock(&mMutex);
+    if (mBusy) {
+        pthread_mutex_unlock(&mMutex);
+        ATRACE_END();
+        ALOGE("%s:id%d: Error, device already in use.", __func__, mId);
+        return -EBUSY;
+    }
+
+    // TODO: open camera dev nodes, etc
+    mBusy = true;
+
+    pthread_mutex_unlock(&mMutex);
+    ATRACE_END();
+    return 0;
+}
+
+int Camera::close()
+{
+    ALOGV("%s: camera id %d", __func__, mId);
+    ATRACE_BEGIN("close");
+    pthread_mutex_lock(&mMutex);
+    if (!mBusy) {
+        pthread_mutex_unlock(&mMutex);
+        ATRACE_END();
+        ALOGE("%s:id%d: Error, close() on not open device.", __func__, mId);
+        return -EINVAL;
+    }
+
+    // TODO: close camera dev nodes, etc
+    mBusy = false;
+
+    pthread_mutex_unlock(&mMutex);
+    ATRACE_END();
+    return 0;
+}
+
+int Camera::getCameraInfo(struct camera_info* info)
+{
+    ALOGV("%s: camera id %d: info=%p", __func__, mId, info);
+    init();
+    if (mMetadata == NULL) {
+        ALOGE("%s:id%d: unable to initialize metadata.", __func__, mId);
+        return -ENOENT;
+    }
+
+    // TODO: fill remainder of info struct
+    info->static_camera_characteristics = mMetadata;
+
+    return 0;
+}
+
+void Camera::init()
+{
+    ATRACE_BEGIN("init");
+    pthread_mutex_lock(&mMutex);
+    if (mMetadata != NULL) {
+        pthread_mutex_unlock(&mMutex);
+        ATRACE_END();
+        return;
+    }
+
+    // TODO: init metadata, dummy value for now
+    mMetadata = allocate_camera_metadata(1,1);
+
+    pthread_mutex_unlock(&mMutex);
+    ATRACE_END();
+}
+
+} // namespace default_camera_hal
diff --git a/modules/camera/Camera.h b/modules/camera/Camera.h
new file mode 100644
index 0000000..ca66406
--- /dev/null
+++ b/modules/camera/Camera.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef CAMERA_H_
+#define CAMERA_H_
+
+#include <pthread.h>
+#include <hardware/camera_common.h>
+#include <hardware/camera2.h>
+
+namespace default_camera_hal {
+// Camera represents a physical camera on a device.
+// This is constructed when the HAL module is loaded, one per physical camera.
+// It is opened by the framework, and must be closed before it can be opened
+// again.
+// Also, the framework can query for camera metadata with getCameraInfo.
+// For the first query, the metadata must first be allocated and initialized,
+// but once done it is used for all future calls.
+// It is protected by @mMutex, and functions that modify the Camera object hold
+// this lock when performing modifications.  Currently these functions are:
+// @open, @close, and @init.
+class Camera {
+    public:
+        // id is used to distinguish cameras. 0 <= id < NUM_CAMERAS.
+        // module is a handle to the HAL module, used when the device is opened.
+        Camera(int id, const hw_module_t* module);
+        ~Camera();
+
+        // Common Camera Device Operations (see <hardware/camera_common.h>)
+        camera2_device_t mDevice;
+        int open();
+        int close();
+        int getCameraInfo(struct camera_info* info);
+
+    private:
+        // One-time initialization of camera metadata.
+        void init();
+        // Identifier used by framework to distinguish cameras
+        int mId;
+        // True indicates camera is already open.
+        bool mBusy;
+        // Camera characteristics. NULL means it has not been allocated yet.
+        camera_metadata_t* mMetadata;
+        // Lock protecting the Camera object for modifications
+        pthread_mutex_t mMutex;
+};
+} // namespace default_camera_hal
+
+#endif // CAMERA_H_
diff --git a/modules/camera/CameraHAL.cpp b/modules/camera/CameraHAL.cpp
new file mode 100644
index 0000000..22c7aef
--- /dev/null
+++ b/modules/camera/CameraHAL.cpp
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cstdlib>
+#include <hardware/camera2.h>
+
+//#define LOG_NDEBUG 0
+#define LOG_TAG "CameraHAL"
+#include <cutils/log.h>
+
+#include "Camera.h"
+
+/*
+ * This file serves as the entry point to the HAL.  It contains the module
+ * structure and functions used by the framework to load and interface to this
+ * HAL, as well as the handles to the individual camera devices.
+ */
+
+namespace default_camera_hal {
+
+enum camera_id_t {
+    CAMERA_A,
+    CAMERA_B,
+    NUM_CAMERAS
+};
+
+// Symbol used by the framework when loading the HAL, defined below.
+extern "C" camera_module_t HAL_MODULE_INFO_SYM;
+
+// Camera devices created when the module is loaded. See Camera.h
+static Camera gCameras[NUM_CAMERAS] = {
+    Camera(CAMERA_A, &HAL_MODULE_INFO_SYM.common),
+    Camera(CAMERA_B, &HAL_MODULE_INFO_SYM.common)
+};
+
+extern "C" {
+
+static int get_number_of_cameras()
+{
+    ALOGV("%s", __func__);
+    return NUM_CAMERAS;
+}
+
+static int get_camera_info(int id, struct camera_info* info)
+{
+    ALOGV("%s: camera id %d: info=%p", __func__, id, info);
+    if (id < 0 || id >= NUM_CAMERAS) {
+        ALOGE("%s: Invalid camera id %d", __func__, id);
+        return -ENODEV;
+    }
+    return gCameras[id].getCameraInfo(info);
+}
+
+static int open_device(const hw_module_t* module,
+                       const char* name,
+                       hw_device_t** device)
+{
+    ALOGV("%s: module=%p, name=%s, device=%p", __func__, module, name, device);
+    char *nameEnd;
+    int id;
+
+    id = strtol(name, &nameEnd, 10);
+    if (nameEnd != NULL) {
+        ALOGE("%s: Invalid camera id name %s", __func__, name);
+        return -EINVAL;
+    } else if (id < 0 || id >= NUM_CAMERAS) {
+        ALOGE("%s: Invalid camera id %d", __func__, id);
+        return -ENODEV;
+    }
+    *device = &gCameras[id].mDevice.common;
+    return gCameras[id].open();
+}
+
+static hw_module_methods_t gCameraModuleMethods = {
+    open : open_device
+};
+
+camera_module_t HAL_MODULE_INFO_SYM = {
+    common : {
+        tag                : HARDWARE_MODULE_TAG,
+        module_api_version : CAMERA_MODULE_API_VERSION_2_0,
+        hal_api_version    : HARDWARE_HAL_API_VERSION,
+        id                 : CAMERA_HARDWARE_MODULE_ID,
+        name               : "Reference Camera v2 HAL",
+        author             : "The Android Open Source Project",
+        methods            : &gCameraModuleMethods,
+        dso                : NULL,
+        reserved           : {0},
+    },
+    get_number_of_cameras : get_number_of_cameras,
+    get_camera_info       : get_camera_info
+};
+
+} // extern "C"
+} // namespace default_camera_hal
diff --git a/tests/camera2/Android.mk b/tests/camera2/Android.mk
index a13ca79..b312328 100644
--- a/tests/camera2/Android.mk
+++ b/tests/camera2/Android.mk
@@ -38,7 +38,7 @@
 	frameworks/av/services/camera/libcameraservice \
 	frameworks/native/include \
 
-LOCAL_CFLAGS += -Wall -Wextra -include FutureMetadata.h
+LOCAL_CFLAGS += -Wall -Wextra
 
 LOCAL_MODULE:= camera2_test
 LOCAL_MODULE_TAGS := tests
diff --git a/tests/camera2/CameraFrameTests.cpp b/tests/camera2/CameraFrameTests.cpp
index fc681c4..13d1b17 100644
--- a/tests/camera2/CameraFrameTests.cpp
+++ b/tests/camera2/CameraFrameTests.cpp
@@ -115,8 +115,18 @@
     for (int i = 0; i < GetParam(); ++i) {
         ALOGV("Reading capture request %d", i);
         ASSERT_EQ(OK, mDevice->waitForNextFrame(CAMERA_FRAME_TIMEOUT));
+
         CameraMetadata frameMetadata;
         ASSERT_EQ(OK, mDevice->getNextFrame(&frameMetadata));
+
+        // wait for buffer to be available
+        ASSERT_EQ(OK, mFrameListener->waitForFrame(CAMERA_FRAME_TIMEOUT));
+        ALOGV("We got the frame now");
+
+        // mark buffer consumed so producer can re-dequeue it
+        CpuConsumer::LockedBuffer imgBuffer;
+        ASSERT_EQ(OK, mCpuConsumer->lockNextBuffer(&imgBuffer));
+        ASSERT_EQ(OK, mCpuConsumer->unlockBuffer(imgBuffer));
     }
 
 }
diff --git a/tests/camera2/CameraModuleFixture.h b/tests/camera2/CameraModuleFixture.h
index 6ad1ae8..cd8ddc4 100644
--- a/tests/camera2/CameraModuleFixture.h
+++ b/tests/camera2/CameraModuleFixture.h
@@ -37,14 +37,10 @@
         TEST_EXTENSION_FORKING_CONSTRUCTOR;
 
         mCameraID = CameraID;
-
-        SetUp();
     }
 
     ~CameraModuleFixture() {
         TEST_EXTENSION_FORKING_DESTRUCTOR;
-
-        TearDown();
     }
 
     camera_metadata_ro_entry GetStaticEntry(uint32_t tag) const {
@@ -53,8 +49,6 @@
         return entry;
     }
 
-private:
-
     void SetUp() {
         TEST_EXTENSION_FORKING_SET_UP;
 
@@ -88,6 +82,8 @@
         }
     }
 
+private:
+
     void SetUpMixin() {
         /* For using this fixture in other tests only */
         if (mCameraID != -1) {
diff --git a/tests/camera2/CameraModuleTests.cpp b/tests/camera2/CameraModuleTests.cpp
index 5e85698..fc6fd36 100644
--- a/tests/camera2/CameraModuleTests.cpp
+++ b/tests/camera2/CameraModuleTests.cpp
@@ -33,6 +33,38 @@
 
 class CameraModuleTest : public ::testing::Test,
                                   public CameraModuleFixture<> {
+
+public:
+    CameraModuleTest() {
+        CameraModuleFixture::SetUp();
+    }
+
+    ~CameraModuleTest() {
+        CameraModuleFixture::TearDown();
+    }
+
+    status_t initializeDevice(int cameraId) {
+
+        // ignore HAL1s. count as test pass
+        status_t stat;
+        if (isDeviceVersionHal2(cameraId, &stat) && stat == OK) {
+            stat = mDevice->initialize(mModule);
+        }
+
+        return stat;
+    }
+
+    int getDeviceVersion(int cameraId, status_t* status) {
+        camera_info info;
+        *status = mModule->get_camera_info(cameraId, &info);
+
+        return info.device_version;
+    }
+
+    bool isDeviceVersionHal2(int cameraId, status_t* status) {
+        return getDeviceVersion(cameraId, status)
+               >= CAMERA_DEVICE_API_VERSION_2_0;
+    }
 };
 
 TEST_F(CameraModuleTest, LoadModule) {
@@ -41,7 +73,8 @@
 
     for (int i = 0; i < mNumberOfCameras; ++i) {
         mDevice = new Camera2Device(i);
-        ASSERT_EQ(OK, mDevice->initialize(mModule))
+
+        ASSERT_EQ(OK, initializeDevice(i))
             << "Failed to initialize device " << i;
         mDevice.clear();
     }
@@ -56,7 +89,7 @@
 
     for (unsigned i = 0; i < sizeof(idx)/sizeof(idx[0]); ++i) {
         mDevice = new Camera2Device(idx[i]);
-        status_t deviceInitializeCode = mDevice->initialize(mModule);
+        status_t deviceInitializeCode = initializeDevice(idx[i]);
         EXPECT_NE(OK, deviceInitializeCode);
         EXPECT_EQ(-ENODEV, deviceInitializeCode)
             << "Incorrect error code when trying to initialize invalid index "
diff --git a/tests/camera2/CameraStreamFixture.h b/tests/camera2/CameraStreamFixture.h
index 7a6fa31..569b9d1 100644
--- a/tests/camera2/CameraStreamFixture.h
+++ b/tests/camera2/CameraStreamFixture.h
@@ -68,6 +68,8 @@
     void SetUp() {
         TEST_EXTENSION_FORKING_SET_UP;
 
+        CameraModuleFixture::SetUp();
+
         CameraStreamParams p = mParam;
         sp<Camera2Device> device = mDevice;
 
@@ -89,6 +91,13 @@
     }
     void TearDown() {
         TEST_EXTENSION_FORKING_TEAR_DOWN;
+
+        // important: shut down HAL before releasing streams
+        CameraModuleFixture::TearDown();
+
+        mNativeWindow.clear();
+        mCpuConsumer.clear();
+        mFrameListener.clear();
     }
 
 protected:
diff --git a/tests/camera2/FutureMetadata.h b/tests/camera2/FutureMetadata.h
deleted file mode 100644
index 58ea698..0000000
--- a/tests/camera2/FutureMetadata.h
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Copyright (C) 2012 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/*
- * Rename select master metadata 2.0 symbols to metadata symbols in jb-mr1-dev
- * - this avoids having to bring in cross-repo changes
- */
-
-#ifndef __ANDROID_HAL_CAMERA2_TESTS_FUTURE_METADATA__
-#define __ANDROID_HAL_CAMERA2_TESTS_FUTURE_METADATA__
-
-#define ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE ANDROID_SENSOR_EXPOSURE_TIME_RANGE
-#define ANDROID_CONTROL_MODE_OFF ANDROID_CONTROL_OFF
-
-#endif
diff --git a/tests/camera2/camera2.cpp b/tests/camera2/camera2.cpp
index fbb0503..de5b8c6 100644
--- a/tests/camera2/camera2.cpp
+++ b/tests/camera2/camera2.cpp
@@ -214,7 +214,7 @@
 
     }
 
-    void setUpStream(sp<ISurfaceTexture> consumer,
+    void setUpStream(sp<IGraphicBufferProducer> consumer,
             int width, int height, int format, int *id) {
         status_t res;
 
@@ -283,6 +283,26 @@
         *count = availableSizes.count;
     }
 
+    status_t waitUntilDrained() {
+        static const uint32_t kSleepTime = 50000; // 50 ms
+        static const uint32_t kMaxSleepTime = 10000000; // 10 s
+        ALOGV("%s: Camera %d: Starting wait", __FUNCTION__, mId);
+
+        // TODO: Set up notifications from HAL, instead of sleeping here
+        uint32_t totalTime = 0;
+        while (mDevice->ops->get_in_progress_count(mDevice) > 0) {
+            usleep(kSleepTime);
+            totalTime += kSleepTime;
+            if (totalTime > kMaxSleepTime) {
+                ALOGE("%s: Waited %d us, %d requests still in flight", __FUNCTION__,
+                        mDevice->ops->get_in_progress_count(mDevice), totalTime);
+                return TIMED_OUT;
+            }
+        }
+        ALOGV("%s: Camera %d: HAL is idle", __FUNCTION__, mId);
+        return OK;
+    }
+
     virtual void SetUp() {
         TEST_EXTENSION_FORKING_SET_UP;
 
@@ -387,7 +407,7 @@
         camera_metadata_t *request;
         request = allocate_camera_metadata(20, 2000);
 
-        uint8_t metadataMode = ANDROID_REQUEST_METADATA_FULL;
+        uint8_t metadataMode = ANDROID_REQUEST_METADATA_MODE_FULL;
         add_camera_metadata_entry(request,
                 ANDROID_REQUEST_METADATA_MODE,
                 (void**)&metadataMode, 1);
@@ -408,6 +428,10 @@
         add_camera_metadata_entry(request,
                 ANDROID_SENSOR_SENSITIVITY,
                 (void**)&sensitivity, 1);
+        uint8_t requestType = ANDROID_REQUEST_TYPE_CAPTURE;
+        add_camera_metadata_entry(request,
+                ANDROID_REQUEST_TYPE,
+                (void**)&requestType, 1);
 
         uint32_t hourOfDay = 12;
         add_camera_metadata_entry(request,
@@ -460,6 +484,7 @@
         res = rawConsumer->unlockBuffer(buffer);
         ASSERT_EQ(NO_ERROR, res);
 
+        ASSERT_EQ(OK, waitUntilDrained());
         ASSERT_NO_FATAL_FAILURE(disconnectStream(streamId));
 
         res = closeCameraDevice(mDevice);
@@ -504,7 +529,7 @@
         camera_metadata_t *request;
         request = allocate_camera_metadata(20, 2000);
 
-        uint8_t metadataMode = ANDROID_REQUEST_METADATA_FULL;
+        uint8_t metadataMode = ANDROID_REQUEST_METADATA_MODE_FULL;
         add_camera_metadata_entry(request,
                 ANDROID_REQUEST_METADATA_MODE,
                 (void**)&metadataMode, 1);
@@ -521,6 +546,10 @@
         add_camera_metadata_entry(request,
                 ANDROID_SENSOR_SENSITIVITY,
                 (void**)&sensitivity, 1);
+        uint8_t requestType = ANDROID_REQUEST_TYPE_CAPTURE;
+        add_camera_metadata_entry(request,
+                ANDROID_REQUEST_TYPE,
+                (void**)&requestType, 1);
 
         uint32_t hourOfDay = 12;
         add_camera_metadata_entry(request,
@@ -669,7 +698,7 @@
         camera_metadata_t *request;
         request = allocate_camera_metadata(20, 2000);
 
-        uint8_t metadataMode = ANDROID_REQUEST_METADATA_FULL;
+        uint8_t metadataMode = ANDROID_REQUEST_METADATA_MODE_FULL;
         add_camera_metadata_entry(request,
                 ANDROID_REQUEST_METADATA_MODE,
                 (void**)&metadataMode, 1);
@@ -690,6 +719,10 @@
         add_camera_metadata_entry(request,
                 ANDROID_SENSOR_SENSITIVITY,
                 (void**)&sensitivity, 1);
+        uint8_t requestType = ANDROID_REQUEST_TYPE_CAPTURE;
+        add_camera_metadata_entry(request,
+                ANDROID_REQUEST_TYPE,
+                (void**)&requestType, 1);
 
         uint32_t hourOfDay = 12;
         add_camera_metadata_entry(request,
@@ -742,6 +775,7 @@
         res = jpegConsumer->unlockBuffer(buffer);
         ASSERT_EQ(NO_ERROR, res);
 
+        ASSERT_EQ(OK, waitUntilDrained());
         ASSERT_NO_FATAL_FAILURE(disconnectStream(streamId));
 
         res = closeCameraDevice(mDevice);
diff --git a/tests/camera2/camera2_utils.cpp b/tests/camera2/camera2_utils.cpp
index 166ac52..501cd71 100644
--- a/tests/camera2/camera2_utils.cpp
+++ b/tests/camera2/camera2_utils.cpp
@@ -317,7 +317,7 @@
     (type *)((char*)(ptr) - offsetof(type, member))
 #endif
 
-StreamAdapter::StreamAdapter(sp<ISurfaceTexture> consumer):
+StreamAdapter::StreamAdapter(sp<IGraphicBufferProducer> consumer):
         mState(UNINITIALIZED), mDevice(NULL),
         mId(-1),
         mWidth(0), mHeight(0), mFormat(0)
diff --git a/tests/camera2/camera2_utils.h b/tests/camera2/camera2_utils.h
index 757044b..c846317 100644
--- a/tests/camera2/camera2_utils.h
+++ b/tests/camera2/camera2_utils.h
@@ -161,12 +161,12 @@
 };
 
 /**
- * Adapter from an ISurfaceTexture interface to camera2 device stream ops.
+ * Adapter from an IGraphicBufferProducer interface to camera2 device stream ops.
  * Also takes care of allocating/deallocating stream in device interface
  */
 class StreamAdapter: public camera2_stream_ops {
   public:
-    StreamAdapter(sp<ISurfaceTexture> consumer);
+    StreamAdapter(sp<IGraphicBufferProducer> consumer);
 
     ~StreamAdapter();