Added tested and corrected accelerometer support for the following MacBook / MacBook Pro models:

chrome/browser/device_orientation/accelerometer_mac.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // This file is based on the SMSLib library.
 //
 // SMSLib Sudden Motion Sensor Access Library
 // Copyright (c) 2010 Suitable Systems
 // All rights reserved.
 //
@@ skipping 41 matching lines @@
 
 #include <math.h>  // For isfinite.
 #include <sys/sysctl.h>
 
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
 #include "chrome/browser/device_orientation/orientation.h"
 
 namespace device_orientation {
 
-// Per-axis sensor data.
+struct AccelerometerMac::GenericMacbookSensor {
+  // Name of device to be read.
+  const char* service_name;
+
+  // Number of bytes of the axis data.
+  int axis_size;
+
+  // Default calibration value for zero g.
+  float zero_g;
+
+  // Default calibration value for one g (negative when axis is inverted).
+  float one_g;
+
+  // Kernel function index.
+  unsigned int function;
+
+  // Size of the sensor record to be sent/received.
+  unsigned int record_size;
+};
+
 struct AccelerometerMac::AxisData {
-  // Non-zero if the axis is valid in this sensor.
-  int enabled;
-
-  // Location in struct of first byte.
+  // Location of the first byte representing the axis in the sensor data.
   int index;
 
-  // Number of bytes of the axis data.
-  int size;
-
-  // Value meaning "zero g".
-  float zero_g;
-
-  // (can be negative if the sensor axis is reversed).
-  float one_g;
+  // Axis inversion flag. The value changes often between models.
+  bool inverted;
 };
 
 // Sudden Motion Sensor descriptor.
 struct AccelerometerMac::SensorDescriptor {
   // Prefix of model to be tested.
   const char* model_name;
 
-  // Name of device to be read.
-  const char* service_name;
+  // Axis-specific data (x,y,z order).
+  AxisData axis[3];
+};
 
-  // Kernel function index.
-  unsigned int function;
-
-  // Size of record to be sent/received.
-  unsigned int record_size;
-
-  // Description of three axes (x,y,z).
-  AxisData axes[3];
+// Typical sensor parameters in MacBook models.
+const AccelerometerMac::GenericMacbookSensor
+  AccelerometerMac::kGenericSensor = {
+  "SMCMotionSensor", 2,
+  0, 251,
+  5, 40
 };
 
 // Supported sensor descriptors. Add entries here to enhance compatibility.
 // All non-tested entries from SMSLib have been removed.
 const AccelerometerMac::SensorDescriptor
     AccelerometerMac::kSupportedSensors[] = {
   // Tested by leandrogracia on a 15'' MacBook Pro.
-  { "MacBookPro5,4", "SMCMotionSensor", 5, 40, {
-    { 1, 0, 2, 0,  251 },
-    { 1, 2, 2, 0,  251 },
-    { 1, 4, 2, 0,  251 }
-  } },
+  { "MacBookPro2,2", { { 0, true  }, { 2, true  }, { 4, false } } },
+
+  // Tested by leandrogracia on a 15'' MacBook Pro.
+  { "MacBookPro3,1", { { 0, false }, { 2, true  }, { 4, true  } } },
+
+  // Tested by leandrogracia on a 15'' MacBook Pro.
+  { "MacBookPro4,1", { { 0, true  }, { 2, true  }, { 4, false } } },
+
+  // Tested by leandrogracia on a 15'' MacBook Pro.
+  { "MacBookPro5,1", { { 0, false }, { 2, false }, { 4, false } } },
+
+  // Tested by leandrogracia on a 15'' MacBook Pro.
+  { "MacBookPro5,4", { { 0, false }, { 2, false }, { 4, false } } },
 
   // Tested by leandrogracia on a 13'' MacBook Pro.
-  { "MacBookPro5,5", "SMCMotionSensor", 5, 40, {
-    { 1, 0, 2, 0, -251 },
-    { 1, 2, 2, 0, -251 },
-    { 1, 4, 2, 0,  251 }
-  } },
+  { "MacBookPro5,5", { { 0, true  }, { 2, true  }, { 4, false } } },
+
+  // Tested by leandrogracia on a 15'' MacBook Pro.
+  { "MacBookPro6,2", { { 0, true  }, { 2, false }, { 4, true  } } },
+
+  // Tested by leandrogracia on a 13'' MacBook Pro.
+  { "MacBookPro7,1", { { 0, true  }, { 2, true  }, { 4, false } } },
 
   // Generic MacBook accelerometer sensor data.
-  // Added for forward compatibility (there may be problems with inverted axes).
-  {"", "SMCMotionSensor", 5, 40, {
-    { 1, 0, 2, 0, -251 },
-    { 1, 2, 2, 0, -251 },
-    { 1, 4, 2, 0,  251 }
-  } }
+  // Added for compatibility with non-tested models
+  // Note: there may be problems with inverted axes.
+  { "", { { 0, true  }, { 2, true  }, { 4, false } } }
 };
 
 // Create a AccelerometerMac object and return NULL if no valid sensor found.
 DataFetcher* AccelerometerMac::Create() {
   scoped_ptr<AccelerometerMac> accelerometer(new AccelerometerMac);
   return accelerometer->Init() ? accelerometer.release() : NULL;
 }
 
 AccelerometerMac::~AccelerometerMac() {
   IOServiceClose(io_connection_);
@@ skipping 13 matching lines @@
 //
 //  Returns false in case of error or non-properly initialized object.
 //
 bool AccelerometerMac::GetOrientation(Orientation* orientation) {
   DCHECK(sensor_);
 
   // Reset output record memory buffer.
   std::fill(output_record_.begin(), output_record_.end(), 0x00);
 
   // Read record data from memory.
-  const size_t kInputSize = sensor_->record_size;
-  size_t output_size = sensor_->record_size;
+  const size_t kInputSize = kGenericSensor.record_size;
+  size_t output_size = kGenericSensor.record_size;
 
-  if (IOConnectCallStructMethod(io_connection_, sensor_->function,
+  if (IOConnectCallStructMethod(io_connection_, kGenericSensor.function,
       static_cast<const char *>(&input_record_[0]), kInputSize,
       &output_record_[0], &output_size) != KERN_SUCCESS) {
     return false;
   }
 
   // Calculate per-axis calibrated values.
   float axis_value[3];
 
   for (int i = 0; i < 3; ++i) {
     int sensor_value = 0;
-    int size  = sensor_->axes[i].size;
-    int index = sensor_->axes[i].index;
+    int size  = kGenericSensor.axis_size;
+    int index = sensor_->axis[i].index;
 
     // Important Note: little endian is assumed as this code is mac-only
     //                 and PowerPC is currently not supported.
     memcpy(&sensor_value, &output_record_[index], size);
 
     sensor_value = ExtendSign(sensor_value, size);
 
     // Correct value using the current calibration.
-    axis_value[i] = static_cast<float>(sensor_value - sensor_->axes[i].zero_g) /
-                    sensor_->axes[i].one_g;
+    axis_value[i] = static_cast<float>(sensor_value - kGenericSensor.zero_g) /
+                    kGenericSensor.one_g;
 
     // Make sure we reject any NaN or infinite values.
     if (!isfinite(axis_value[i]))
       return false;
 
     // Clamp value to the [-1, 1] range.
     if (axis_value[i] < -1.0)
       axis_value[i] = -1.0;
     else if (axis_value[i] > 1.0)
       axis_value[i] = 1.0;
+
+    // Apply axis inversion.
+    if (sensor_->axis[i].inverted)
+      axis_value[i] = -axis_value[i];
   }
 
   // Transform the accelerometer values to W3C draft angles.
   //
   // Accelerometer values are just dot products of the sensor axes
   // by the gravity vector 'g' with the result for the z axis inverted.
   //
   // To understand this transformation calculate the 3rd row of the z-x-y
   // Euler angles rotation matrix (because of the 'g' vector, only 3rd row
   // affects to the result). Note that z-x-y matrix means R = Ry * Rx * Rz.
@@ skipping 59 matching lines @@
     for (const char* p2 = local_model; *p1 != '\0' && *p1 == *p2; ++p1, ++p2)
       continue;
     if (*p1 != '\0')
       continue;
 
     // Local hardware found in the supported sensor list.
     sensor_candidate = &kSupportedSensors[i];
 
     // Get a dictionary of the services matching to the one in the sensor.
     CFMutableDictionaryRef dict =
-        IOServiceMatching(sensor_candidate->service_name);
+        IOServiceMatching(kGenericSensor.service_name);
     if (dict == NULL)
       continue;
 
     // Get an iterator for the matching services.
     io_iterator_t device_iterator;
     if (IOServiceGetMatchingServices(kIOMasterPortDefault, dict,
         &device_iterator) != KERN_SUCCESS) {
       continue;
     }
 
@@ skipping 10 matching lines @@
 
     // Local sensor service confirmed by IOKit.
     sensor_ = sensor_candidate;
     break;
   }
 
   if (sensor_ == NULL)
     return false;
 
   // Allocate and initialize input/output records.
-  input_record_.resize(sensor_->record_size, 0x01);
-  output_record_.resize(sensor_->record_size, 0x00);
+  input_record_.resize(kGenericSensor.record_size, 0x01);
+  output_record_.resize(kGenericSensor.record_size, 0x00);
 
   // Try to retrieve the current orientation.
   Orientation test_orientation;
   return GetOrientation(&test_orientation);
 }
 
 // Extend the sign of an integer of less than 32 bits to a 32-bit integer.
 int AccelerometerMac::ExtendSign(int value, size_t size) {
   switch (size) {
   case 1:
@@ skipping 12 matching lines @@
     break;
 
   default:
     LOG(FATAL) << "Invalid integer size for sign extension: " << size;
   }
 
   return value;
 }
 
 }  // namespace device_orientation