diff --git a/usb/Makefile b/usb/Makefile
new file mode 100644
index 0000000..8899aa5
--- /dev/null
+++ b/usb/Makefile
@@ -0,0 +1,34 @@
+# Copyright 2016 The Chromium OS Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+include common.mk
+
+PC_DEPS = libbrillo-$(BASE_VER) libchrome-$(BASE_VER)
+PC_CFLAGS := $(shell SYSROOT=$(SYSROOT) $(PKG_CONFIG) --cflags $(PC_DEPS))
+PC_LIBS := $(shell SYSROOT=$(SYSROOT) $(PKG_CONFIG) --libs $(PC_DEPS))
+
+ANDROID_INCLUDE := $(abspath $(SRC)/../android/include)
+ANDROID_INCLUDE_PATHS := \
+	-I$(ANDROID_INCLUDE) \
+	-I$(ANDROID_INCLUDE)/hardware/libhardware/include \
+	-I$(ANDROID_INCLUDE)/system/core/include \
+	-I$(ANDROID_INCLUDE)/system/core/libsync/include \
+	-I$(ANDROID_INCLUDE)/system/media/camera/include \
+	-I$(ANDROID_INCLUDE)/system/media/private/camera/include
+
+CPPFLAGS += $(PC_CFLAGS) $(ANDROID_INCLUDE_PATHS) -I$(abspath $(SRC)/../)
+CXXFLAGS += -std=c++11 -Wall -Wpointer-arith
+CFLAGS += -Wall -std=gnu99
+
+LDLIBS += $(PC_LIBS)
+
+CXX_LIBRARY(libarccamera.so): $(CXX_OBJECTS)
+
+all: CXX_LIBRARY(libarccamera.so)
+
+clean: CLEAN(libarccamera.so)
+
+install: all
+	mkdir -p $(DESTDIR)/usr/lib
+	install -m 644 $(OUT)/libarccamera.so $(DESTDIR)/usr/lib
diff --git a/usb/camera_characteristics.cc b/usb/camera_characteristics.cc
new file mode 100644
index 0000000..5aecf58
--- /dev/null
+++ b/usb/camera_characteristics.cc
@@ -0,0 +1,258 @@
+/*
+ * Copyright 2016 The Chromium OS Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "usb/camera_characteristics.h"
+
+#include <vector>
+
+#include <base/files/file_util.h>
+
+#include "usb/common.h"
+
+namespace arc {
+
+// /etc/camera/camera_characteristics.conf contains camera information which
+// driver cannot provide.
+static const char kCameraCharacteristicsConfigFile[] =
+    "/etc/camera/camera_characteristics.conf";
+static const char kLensFacing[] = "lens_facing";
+static const char kSensorOrientation[] = "sensor_orientation";
+static const char kUsbVidPid[] = "usb_vid_pid";
+static const char kFramesToSkipAfterStreamon[] =
+    "frames_to_skip_after_streamon";
+static const char kHorizontalViewAngle_16_9[] = "horizontal_view_angle_16_9";
+static const char kHorizontalViewAngle_4_3[] = "horizontal_view_angle_4_3";
+static const char kLensInfoAvailableFocalLengths[] =
+    "lens_info_available_focal_lengths";
+static const char kLensInfoMinimumFocusDistance[] =
+    "lens_info_minimum_focus_distance";
+static const char kLensInfoOptimalFocusDistance[] =
+    "lens_info_optimal_focus_distance";
+static const char kVerticalViewAngle_16_9[] = "vertical_view_angle_16_9";
+static const char kVerticalViewAngle_4_3[] = "vertical_view_angle_4_3";
+
+/* HAL v3 parameters */
+static const char kLensInfoAvailableApertures[] =
+    "lens_info_available_apertures";
+static const char kSensorInfoPhysicalSize[] = "sensor_info_physical_size";
+static const char kSensorInfoPixelArraySize[] = "sensor_info_pixel_array_size";
+
+static const struct DeviceInfo kDefaultCharacteristics = {
+    "",     // device_path
+    "",     // usb_vid
+    "",     // usb_pid
+    0,      // lens_facing
+    0,      // sensor_orientation
+    0,      // frames_to_skip_after_streamon
+    66.5,   // horizontal_view_angle_16_9
+    0.0,    // horizontal_view_angle_4_3
+    {1.6},  // lens_info_available_focal_lengths
+    0.3,    // lens_info_minimum_focus_distance
+    0.5,    // lens_info_optimal_focus_distance
+    42.5,   // vertical_view_angle_16_9
+    0.0     // vertical_view_angle_4_3
+};
+
+CameraCharacteristics::CameraCharacteristics() {}
+
+CameraCharacteristics::~CameraCharacteristics() {}
+
+const DeviceInfos CameraCharacteristics::GetCharacteristicsFromFile(
+    const std::unordered_map<std::string, std::string>& devices) {
+  const base::FilePath path(kCameraCharacteristicsConfigFile);
+  FILE* file = base::OpenFile(path, "r");
+  if (!file) {
+    LOGF(ERROR) << "Can't open file " << kCameraCharacteristicsConfigFile
+                << ". Use default characteristics instead";
+    for (const auto& device : devices) {
+      device_infos_.push_back(kDefaultCharacteristics);
+      size_t pos = device.first.find(":");
+      if (pos != std::string::npos) {
+        device_infos_.back().device_path = device.second;
+        device_infos_.back().usb_vid = device.first.substr(0, pos - 1);
+        device_infos_.back().usb_pid = device.first.substr(pos + 1);
+      } else {
+        LOGF(ERROR) << "Invalid device: " << device.first;
+      }
+    }
+    return device_infos_;
+  }
+
+  char buffer[256], key[256], value[256];
+  uint32_t camera_id;
+  uint32_t module_id = -1;
+  std::string vid, pid;
+  while (fgets(buffer, sizeof(buffer), file)) {
+    // Skip comments and empty lines.
+    if (buffer[0] == '#' || buffer[0] == '\n') {
+      continue;
+    }
+
+    if (sscanf(buffer, "%[^=]=%s", key, value) != 2) {
+      LOGF(ERROR) << "Illegal format: " << buffer;
+      continue;
+    }
+    std::vector<char*> sub_keys;
+    char* save_ptr;
+    char* sub_key = strtok_r(key, ".", &save_ptr);
+    while (sub_key) {
+      sub_keys.push_back(sub_key);
+      sub_key = strtok_r(NULL, ".", &save_ptr);
+    }
+
+    if (sscanf(sub_keys[0], "camera%u", &camera_id) != 1) {
+      LOGF(ERROR) << "Illegal format: " << sub_keys[0];
+      continue;
+    }
+    if (camera_id > device_infos_.size()) {
+      // Camera id should be ascending by one.
+      LOGF(ERROR) << "Invalid camera id: " << camera_id;
+      continue;
+    } else if (camera_id == device_infos_.size()) {
+      device_infos_.push_back(kDefaultCharacteristics);
+    }
+
+    uint32_t tmp_module_id;
+    if (sscanf(sub_keys[1], "module%u", &tmp_module_id) != 1) {
+      AddPerCameraCharacteristic(camera_id, sub_keys[1], value);
+    } else {
+      if (tmp_module_id != module_id) {
+        vid.clear();
+        pid.clear();
+        module_id = tmp_module_id;
+      }
+      if (strcmp(sub_keys[2], kUsbVidPid) == 0) {
+        char tmp_vid[256], tmp_pid[256];
+        if (sscanf(value, "%[0-9a-z]:%[0-9a-z]", tmp_vid, tmp_pid) != 2) {
+          LOGF(ERROR) << "Invalid format: " << sub_keys[2];
+          continue;
+        }
+        vid = tmp_vid;
+        pid = tmp_pid;
+        const auto& device = devices.find(value);
+        if (device != devices.end()) {
+          device_infos_[camera_id].usb_vid = vid;
+          device_infos_[camera_id].usb_pid = pid;
+          device_infos_[camera_id].device_path = device->second;
+        }
+
+        VLOGF(1) << "Camera" << camera_id << " " << kUsbVidPid << ": " << value;
+      } else if (!vid.empty() && !pid.empty()) {
+        // Some characteristics are module-specific, so only matched ones are
+        // selected.
+        if (device_infos_[camera_id].usb_vid != vid ||
+            device_infos_[camera_id].usb_pid != pid) {
+          VLOGF(1) << "Mismatched module: "
+                   << "vid: " << vid << " pid: " << pid;
+          continue;
+        }
+        AddPerModuleCharacteristic(camera_id, sub_keys[2], value);
+      } else {
+        // Characteristic usb_vid_pid should come before other module-specific
+        // characteristics.
+        LOGF(ERROR) << "Illegal format. usb_vid_pid should come before: "
+                    << buffer;
+      }
+    }
+  }
+  base::CloseFile(file);
+  for (size_t id = 0; id < device_infos_.size(); ++id) {
+    if (device_infos_[id].device_path.empty()) {
+      LOGF(ERROR) << "No matching module for camera" << id;
+      return DeviceInfos();
+    }
+  }
+  return device_infos_;
+}
+
+void CameraCharacteristics::AddPerCameraCharacteristic(
+    uint32_t camera_id,
+    const char* characteristic,
+    const char* value) {
+  if (strcmp(characteristic, kLensFacing) == 0) {
+    VLOGF(1) << characteristic << ": " << value;
+    device_infos_[camera_id].lens_facing = strtol(value, NULL, 10);
+  } else if (strcmp(characteristic, kSensorOrientation) == 0) {
+    VLOGF(1) << characteristic << ": " << value;
+    device_infos_[camera_id].sensor_orientation = strtol(value, NULL, 10);
+  } else {
+    LOGF(ERROR) << "Unknown characteristic: " << characteristic
+                << " value: " << value;
+  }
+}
+
+void CameraCharacteristics::AddPerModuleCharacteristic(
+    uint32_t camera_id,
+    const char* characteristic,
+    const char* value) {
+  if (strcmp(characteristic, kFramesToSkipAfterStreamon) == 0) {
+    VLOGF(1) << characteristic << ": " << value;
+    device_infos_[camera_id].frames_to_skip_after_streamon =
+        strtol(value, NULL, 10);
+  } else if (strcmp(characteristic, kHorizontalViewAngle_16_9) == 0) {
+    AddFloatValue(value, kHorizontalViewAngle_16_9,
+                  &device_infos_[camera_id].horizontal_view_angle_16_9);
+  } else if (strcmp(characteristic, kHorizontalViewAngle_4_3) == 0) {
+    AddFloatValue(value, kHorizontalViewAngle_4_3,
+                  &device_infos_[camera_id].horizontal_view_angle_4_3);
+  } else if (strcmp(characteristic, kLensInfoAvailableFocalLengths) == 0) {
+    device_infos_[camera_id].lens_info_available_focal_lengths.clear();
+    char tmp_value[256];
+    snprintf(tmp_value, sizeof(tmp_value), "%s", value);
+    char* save_ptr;
+    char* focal_length = strtok_r(tmp_value, ",", &save_ptr);
+    while (focal_length) {
+      float tmp_focal_length = strtof(focal_length, NULL);
+      if (tmp_focal_length != 0.0) {
+        VLOGF(1) << characteristic << ": " << tmp_focal_length;
+        device_infos_[camera_id].lens_info_available_focal_lengths.push_back(
+            tmp_focal_length);
+      } else {
+        LOGF(ERROR) << "Invalid " << characteristic << ": " << value;
+        device_infos_[camera_id].lens_info_available_focal_lengths.clear();
+        device_infos_[camera_id].lens_info_available_focal_lengths.push_back(
+            kDefaultCharacteristics.lens_info_available_focal_lengths[0]);
+        break;
+      }
+      focal_length = strtok_r(NULL, ",", &save_ptr);
+    }
+  } else if (strcmp(characteristic, kLensInfoMinimumFocusDistance) == 0) {
+    AddFloatValue(value, kLensInfoMinimumFocusDistance,
+                  &device_infos_[camera_id].lens_info_minimum_focus_distance);
+  } else if (strcmp(characteristic, kLensInfoOptimalFocusDistance) == 0) {
+    AddFloatValue(value, kLensInfoOptimalFocusDistance,
+                  &device_infos_[camera_id].lens_info_optimal_focus_distance);
+  } else if (strcmp(characteristic, kVerticalViewAngle_16_9) == 0) {
+    AddFloatValue(value, kVerticalViewAngle_16_9,
+                  &device_infos_[camera_id].vertical_view_angle_16_9);
+  } else if (strcmp(characteristic, kVerticalViewAngle_4_3) == 0) {
+    AddFloatValue(value, kVerticalViewAngle_4_3,
+                  &device_infos_[camera_id].vertical_view_angle_4_3);
+  } else if (strcmp(characteristic, kLensInfoAvailableApertures) == 0) {
+    /* Do nothing. This is for hal v3 */
+  } else if (strcmp(characteristic, kSensorInfoPhysicalSize) == 0) {
+    /* Do nothing. This is for hal v3 */
+  } else if (strcmp(characteristic, kSensorInfoPixelArraySize) == 0) {
+    /* Do nothing. This is for hal v3 */
+  } else {
+    LOGF(ERROR) << "Unknown characteristic: " << characteristic
+                << " value: " << value;
+  }
+}
+
+void CameraCharacteristics::AddFloatValue(const char* value,
+                                          const char* characteristic_name,
+                                          float* characteristic) {
+  float tmp_value = strtof(value, NULL);
+  if (tmp_value != 0.0) {
+    VLOGF(1) << characteristic_name << ": " << value;
+    *characteristic = tmp_value;
+  } else {
+    LOGF(ERROR) << "Invalid " << characteristic_name << ": " << value;
+  }
+}
+
+}  // namespace arc
diff --git a/usb/camera_characteristics.h b/usb/camera_characteristics.h
new file mode 100644
index 0000000..80e3776
--- /dev/null
+++ b/usb/camera_characteristics.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2016 The Chromium OS Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef USB_CAMERA_CHARACTERISTICS_H_
+#define USB_CAMERA_CHARACTERISTICS_H_
+
+#include <string>
+#include <unordered_map>
+
+#include <base/macros.h>
+
+#include "usb/common_types.h"
+
+namespace arc {
+
+// CameraCharacteristics reads the file /etc/camera/camera_characteristics.conf
+// and stores the content. There are several assumptions of the config file:
+//  1. Each line should be at most 256 characters long.
+//  2. camera id should be in ascending order (i.e., 0, 1, 2, ...).
+//  3. usb_vid_pid should be the first subkey.
+//  4. All configs of a module should be put together.
+//
+// Example of the config file:
+//  camera0.lens_facing=0
+//  camera0.sensor_orientation=0
+//  camera0.module0.usb_vid_pid=0123:4567
+//  camera0.module0.horizontal_view_angle=68.4
+//  camera0.module0.lens_info_available_focal_lengths=1.64
+//  camera0.module0.lens_info_minimum_focus_distance=0.22
+//  camera0.module0.lens_info_optimal_focus_distance=0.5
+//  camera0.module0.vertical_view_angle=41.6
+//  camera0.module1.usb_vid_pid=89ab:cdef
+//  camera0.module1.lens_info_available_focal_lengths=1.69,2
+//  camera1.lens_facing=1
+//  camera1.sensor_orientation=180
+class CameraCharacteristics {
+ public:
+  CameraCharacteristics();
+  ~CameraCharacteristics();
+
+  // Parses /etc/camera/camera_characteristics.conf.
+  // Returns DeviceInfos with default characteristics if the config file doesn't
+  // exist.
+  const DeviceInfos GetCharacteristicsFromFile(
+      const std::unordered_map<std::string, std::string>& devices);
+
+ private:
+  DeviceInfos device_infos_;
+
+  void AddPerCameraCharacteristic(uint32_t camera_id,
+                                  const char* characteristic,
+                                  const char* value);
+  void AddPerModuleCharacteristic(uint32_t camera_id,
+                                  const char* characteristic,
+                                  const char* value);
+  void AddFloatValue(const char* value,
+                     const char* characteristic_name,
+                     float* characteristic);
+
+  DISALLOW_COPY_AND_ASSIGN(CameraCharacteristics);
+};
+
+}  // namespace arc
+
+#endif  // USB_CAMERA_CHARACTERISTICS_H_
diff --git a/usb/camera_client.cc b/usb/camera_client.cc
new file mode 100644
index 0000000..8495b42
--- /dev/null
+++ b/usb/camera_client.cc
@@ -0,0 +1,84 @@
+/* Copyright 2016 The Chromium OS Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "usb/camera_client.h"
+
+#include <system/camera_metadata.h>
+
+#include "usb/camera_hal.h"
+#include "usb/camera_hal_device_ops.h"
+#include "usb/common.h"
+
+namespace arc {
+
+CameraClient::CameraClient(int id,
+                           const std::string& device_path,
+                           const hw_module_t* module,
+                           hw_device_t** hw_device)
+    : id_(id), device_path_(device_path) {
+  memset(&device_, 0, sizeof(device_));
+  device_.common.tag = HARDWARE_DEVICE_TAG;
+  device_.common.version = CAMERA_DEVICE_API_VERSION_3_3;
+  device_.common.close = arc::camera_device_close;
+  device_.common.module = const_cast<hw_module_t*>(module);
+  device_.ops = &g_camera_device_ops;
+  device_.priv = this;
+  *hw_device = &device_.common;
+
+  ops_thread_checker_.DetachFromThread();
+}
+
+CameraClient::~CameraClient() {}
+
+int CameraClient::OpenDevice() {
+  VLOGFID(1, id_);
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return 0;
+}
+
+int CameraClient::CloseDevice() {
+  VLOGFID(1, id_);
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return 0;
+}
+
+int CameraClient::Initialize(const camera3_callback_ops_t* callback_ops) {
+  VLOGFID(1, id_);
+  DCHECK(ops_thread_checker_.CalledOnValidThread());
+  return 0;
+}
+
+int CameraClient::ConfigureStreams(
+    camera3_stream_configuration_t* stream_config) {
+  VLOGFID(1, id_);
+  DCHECK(ops_thread_checker_.CalledOnValidThread());
+  return 0;
+}
+
+const camera_metadata_t* CameraClient::ConstructDefaultRequestSettings(
+    int type) {
+  VLOGFID(1, id_);
+  DCHECK(ops_thread_checker_.CalledOnValidThread());
+  return NULL;
+}
+
+int CameraClient::ProcessCaptureRequest(camera3_capture_request_t* request) {
+  VLOGFID(1, id_);
+  DCHECK(ops_thread_checker_.CalledOnValidThread());
+  return 0;
+}
+
+void CameraClient::Dump(int fd) {
+  VLOGFID(1, id_);
+  DCHECK(ops_thread_checker_.CalledOnValidThread());
+}
+
+int CameraClient::Flush(const camera3_device_t* dev) {
+  VLOGFID(1, id_);
+  DCHECK(ops_thread_checker_.CalledOnValidThread());
+  return 0;
+}
+
+}  // namespace arc
diff --git a/usb/camera_client.h b/usb/camera_client.h
new file mode 100644
index 0000000..f520ac6
--- /dev/null
+++ b/usb/camera_client.h
@@ -0,0 +1,70 @@
+/* Copyright 2016 The Chromium OS Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef USB_CAMERA_CLIENT_H_
+#define USB_CAMERA_CLIENT_H_
+
+#include <string>
+
+#include <base/macros.h>
+#include <base/threading/thread_checker.h>
+#include <hardware/camera3.h>
+#include <hardware/hardware.h>
+
+#include "usb/common_types.h"
+
+namespace arc {
+
+// CameraClient class is not thread-safe. Constructor, OpenDevice, and
+// CloseDevice must be called on the same thread. Camera v3 Device
+// Operations must be called on the same thread. But OpenDevice and device
+// operations can be called on different threads.
+class CameraClient {
+ public:
+  // id is used to distinguish cameras. 0 <= id < number of cameras.
+  CameraClient(int id,
+               const std::string& device_path,
+               const hw_module_t* module,
+               hw_device_t** hw_device);
+  ~CameraClient();
+
+  // Camera Device Operations from CameraHal.
+  int OpenDevice();
+  int CloseDevice();
+
+  int GetId() const { return id_; }
+
+  // Camera v3 Device Operations (see <hardware/camera3.h>)
+  int Initialize(const camera3_callback_ops_t* callback_ops);
+  int ConfigureStreams(camera3_stream_configuration_t* stream_list);
+  // |type| is camera3_request_template_t in camera3.h.
+  const camera_metadata_t* ConstructDefaultRequestSettings(int type);
+  int ProcessCaptureRequest(camera3_capture_request_t* request);
+  void Dump(int fd);
+  int Flush(const camera3_device_t* dev);
+
+ private:
+  // Camera device id.
+  const int id_;
+
+  // Camera device path.
+  const std::string device_path_;
+
+  // Camera device handle returned to framework for use.
+  camera3_device_t device_;
+
+  // Use to check the constructor, OpenDevice, and CloseDevice are called on the
+  // same thread.
+  base::ThreadChecker thread_checker_;
+
+  // Use to check camera v3 device operations are called on the same thread.
+  base::ThreadChecker ops_thread_checker_;
+
+  DISALLOW_COPY_AND_ASSIGN(CameraClient);
+};
+
+}  // namespace arc
+
+#endif  // USB_CAMERA_CLIENT_H_
diff --git a/usb/camera_hal.cc b/usb/camera_hal.cc
new file mode 100644
index 0000000..b2ef98e
--- /dev/null
+++ b/usb/camera_hal.cc
@@ -0,0 +1,157 @@
+/* Copyright 2016 The Chromium OS Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "usb/camera_hal.h"
+
+#include <base/lazy_instance.h>
+
+#include "usb/common.h"
+#include "usb/common_types.h"
+#include "usb/v4l2_camera_device.h"
+
+namespace arc {
+
+base::LazyInstance<CameraHal> g_camera_hal = LAZY_INSTANCE_INITIALIZER;
+
+CameraHal::CameraHal() {
+  device_infos_ = V4L2CameraDevice().GetCameraDeviceInfos();
+  VLOGF(1) << "Number of cameras is " << GetNumberOfCameras();
+}
+
+CameraHal::~CameraHal() {}
+
+CameraHal& CameraHal::GetInstance() {
+  return g_camera_hal.Get();
+}
+
+int CameraHal::OpenDevice(int id,
+                          const hw_module_t* module,
+                          hw_device_t** hw_device) {
+  VLOGFID(1, id);
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (id < 0 || id >= GetNumberOfCameras()) {
+    LOGF(ERROR) << "Camera id " << id << " is out of bounds [0,"
+                << GetNumberOfCameras() - 1 << "]";
+    return -EINVAL;
+  }
+
+  if (cameras_.find(id) != cameras_.end()) {
+    LOGF(ERROR) << "Camera " << id << " is already opened";
+    return -EBUSY;
+  }
+  cameras_[id].reset(
+      new CameraClient(id, device_infos_[id].device_path, module, hw_device));
+  if (cameras_[id]->OpenDevice()) {
+    cameras_.erase(id);
+    return -ENODEV;
+  }
+  return 0;
+}
+
+int CameraHal::GetCameraInfo(int id, struct camera_info* info) {
+  VLOGFID(1, id);
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (id < 0 || id >= GetNumberOfCameras()) {
+    LOGF(ERROR) << "Camera id " << id << " is out of bounds [0,"
+                << GetNumberOfCameras() - 1 << "]";
+    return -EINVAL;
+  }
+
+  info->facing = device_infos_[id].lens_facing;
+  info->orientation = device_infos_[id].sensor_orientation;
+  info->device_version = CAMERA_DEVICE_API_VERSION_3_3;
+  info->static_camera_characteristics = NULL;
+  return 0;
+}
+
+int CameraHal::SetCallbacks(const camera_module_callbacks_t* callbacks) {
+  VLOGF(1) << "New callbacks = " << callbacks;
+  DCHECK(thread_checker_.CalledOnValidThread());
+  callbacks_ = callbacks;
+  return 0;
+}
+
+int CameraHal::CloseDevice(int id) {
+  VLOGFID(1, id);
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (cameras_.find(id) == cameras_.end()) {
+    LOGF(ERROR) << "Failed to close camera device " << id
+                << ": device is not opened";
+    return -EINVAL;
+  }
+  int ret = cameras_[id]->CloseDevice();
+  cameras_.erase(id);
+  return ret;
+}
+
+static int camera_device_open(const hw_module_t* module,
+                              const char* name,
+                              hw_device_t** device) {
+  VLOGF(1);
+  // Make sure hal adapter loads the correct symbol.
+  if (module != &HAL_MODULE_INFO_SYM.common) {
+    LOGF(ERROR) << std::hex << "Invalid module 0x" << module << " expected 0x"
+                << &HAL_MODULE_INFO_SYM.common;
+    return -EINVAL;
+  }
+
+  char* nameEnd;
+  int id = strtol(name, &nameEnd, 10);
+  if (*nameEnd != '\0') {
+    LOGF(ERROR) << "Invalid camera name " << name;
+    return -EINVAL;
+  }
+
+  return CameraHal::GetInstance().OpenDevice(id, module, device);
+}
+
+static int get_number_of_cameras() {
+  return CameraHal::GetInstance().GetNumberOfCameras();
+}
+
+static int get_camera_info(int id, struct camera_info* info) {
+  return CameraHal::GetInstance().GetCameraInfo(id, info);
+}
+
+static int set_callbacks(const camera_module_callbacks_t* callbacks) {
+  return CameraHal::GetInstance().SetCallbacks(callbacks);
+}
+
+int camera_device_close(struct hw_device_t* hw_device) {
+  camera3_device_t* cam_dev = reinterpret_cast<camera3_device_t*>(hw_device);
+  CameraClient* cam = static_cast<CameraClient*>(cam_dev->priv);
+  if (!cam) {
+    LOGF(ERROR) << "Camera device is NULL";
+    return -EIO;
+  }
+  cam_dev->priv = NULL;
+  return CameraHal::GetInstance().CloseDevice(cam->GetId());
+}
+
+}  // namespace arc
+
+static hw_module_methods_t gCameraModuleMethods = {.open =
+                                                       arc::camera_device_open};
+
+camera_module_t HAL_MODULE_INFO_SYM
+    __attribute__((__visibility__("default"))) = {
+        .common = {.tag = HARDWARE_MODULE_TAG,
+                   .module_api_version = CAMERA_MODULE_API_VERSION_2_2,
+                   .hal_api_version = HARDWARE_HAL_API_VERSION,
+                   .id = CAMERA_HARDWARE_MODULE_ID,
+                   .name = "V4L2 Camera HAL v3",
+                   .author = "The Chromium OS Authors",
+                   .methods = &gCameraModuleMethods,
+                   .dso = NULL,
+                   .reserved = {0}},
+        .get_number_of_cameras = arc::get_number_of_cameras,
+        .get_camera_info = arc::get_camera_info,
+        .set_callbacks = arc::set_callbacks,
+        .get_vendor_tag_ops = NULL,
+        .open_legacy = NULL,
+        .set_torch_mode = NULL,
+        .init = NULL,
+        .reserved = {0}};
diff --git a/usb/camera_hal.h b/usb/camera_hal.h
new file mode 100644
index 0000000..585d0aa
--- /dev/null
+++ b/usb/camera_hal.h
@@ -0,0 +1,65 @@
+/* Copyright 2016 The Chromium OS Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef USB_CAMERA_HAL_H_
+#define USB_CAMERA_HAL_H_
+
+#include <map>
+#include <memory>
+
+#include <base/macros.h>
+#include <base/threading/thread_checker.h>
+#include <hardware/camera_common.h>
+
+#include "usb/camera_client.h"
+#include "usb/common_types.h"
+
+namespace arc {
+
+// This class is not thread-safe. All functions in camera_module_t are called by
+// one mojo thread which is in hal adapter. The hal adapter makes sure these
+// functions are not called concurrently. The hal adapter also has different
+// dedicated threads to handle camera_module_callbacks_t, camera3_device_ops_t,
+// and camera3_callback_ops_t.
+class CameraHal {
+ public:
+  CameraHal();
+  ~CameraHal();
+
+  static CameraHal& GetInstance();
+
+  // Implementations for camera_module_t.
+  int OpenDevice(int id, const hw_module_t* module, hw_device_t** hw_device);
+  int GetNumberOfCameras() const { return device_infos_.size(); }
+  // GetCameraInfo can be called before camera is opened when module api
+  // version <= 2.3.
+  int GetCameraInfo(int id, camera_info* info);
+  int SetCallbacks(const camera_module_callbacks_t* callbacks);
+
+  int CloseDevice(int id);
+
+ private:
+  // Cache device information because querying the information is very slow.
+  DeviceInfos device_infos_;
+
+  // The key is camera id.
+  std::map<int, std::unique_ptr<CameraClient>> cameras_;
+
+  const camera_module_callbacks_t* callbacks_;
+
+  // All methods of this class should be run on the same thread.
+  base::ThreadChecker thread_checker_;
+
+  DISALLOW_COPY_AND_ASSIGN(CameraHal);
+};
+
+// Callback for camera_device.common.close().
+int camera_device_close(struct hw_device_t* hw_device);
+
+}  // namespace arc
+
+extern camera_module_t HAL_MODULE_INFO_SYM;
+
+#endif  // USB_CAMERA_HAL_H_
diff --git a/usb/camera_hal_device_ops.cc b/usb/camera_hal_device_ops.cc
new file mode 100644
index 0000000..feba0f2
--- /dev/null
+++ b/usb/camera_hal_device_ops.cc
@@ -0,0 +1,90 @@
+/* Copyright 2016 The Chromium OS Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "usb/camera_hal_device_ops.h"
+
+#include "usb/camera_client.h"
+#include "usb/common.h"
+
+namespace arc {
+
+// Get handle to camera from device priv data
+static CameraClient* camdev_to_camera(const camera3_device_t* dev) {
+  return reinterpret_cast<CameraClient*>(dev->priv);
+}
+
+static int initialize(const camera3_device_t* dev,
+                      const camera3_callback_ops_t* callback_ops) {
+  CameraClient* client = camdev_to_camera(dev);
+  if (!client) {
+    LOGF(ERROR) << "Camera device is NULL";
+    return -ENODEV;
+  }
+  return client->Initialize(callback_ops);
+}
+
+static int configure_streams(const camera3_device_t* dev,
+                             camera3_stream_configuration_t* stream_list) {
+  CameraClient* client = camdev_to_camera(dev);
+  if (!client) {
+    LOGF(ERROR) << "Camera device is NULL";
+    return -ENODEV;
+  }
+  return client->ConfigureStreams(stream_list);
+}
+
+static const camera_metadata_t* construct_default_request_settings(
+    const camera3_device_t* dev,
+    int type) {
+  CameraClient* client = camdev_to_camera(dev);
+  if (!client) {
+    LOGF(ERROR) << "Camera device is NULL";
+    return NULL;
+  }
+  return client->ConstructDefaultRequestSettings(type);
+}
+
+static int process_capture_request(const camera3_device_t* dev,
+                                   camera3_capture_request_t* request) {
+  CameraClient* client = camdev_to_camera(dev);
+  if (!client) {
+    LOGF(ERROR) << "Camera device is NULL";
+    return -ENODEV;
+  }
+  return client->ProcessCaptureRequest(request);
+}
+
+static void dump(const camera3_device_t* dev, int fd) {
+  CameraClient* client = camdev_to_camera(dev);
+  if (!client) {
+    LOGF(ERROR) << "Camera device is NULL";
+    return;
+  }
+  client->Dump(fd);
+}
+
+static int flush(const camera3_device_t* dev) {
+  CameraClient* client = camdev_to_camera(dev);
+  if (!client) {
+    LOGF(ERROR) << "Camera device is NULL";
+    return -ENODEV;
+  }
+  return client->Flush(dev);
+}
+
+camera3_device_ops_t g_camera_device_ops = {
+    .initialize = arc::initialize,
+    .configure_streams = arc::configure_streams,
+    .register_stream_buffers = NULL,
+    .construct_default_request_settings =
+        arc::construct_default_request_settings,
+    .process_capture_request = arc::process_capture_request,
+    .get_metadata_vendor_tag_ops = NULL,
+    .dump = arc::dump,
+    .flush = arc::flush,
+    .reserved = {0},
+};
+
+}  // namespace arc
diff --git a/usb/camera_hal_device_ops.h b/usb/camera_hal_device_ops.h
new file mode 100644
index 0000000..7d51a36
--- /dev/null
+++ b/usb/camera_hal_device_ops.h
@@ -0,0 +1,20 @@
+/* Copyright 2016 The Chromium OS Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef USB_CAMERA_HAL_DEVICE_OPS_H_
+#define USB_CAMERA_HAL_DEVICE_OPS_H_
+
+#include <hardware/camera3.h>
+
+namespace arc {
+
+// Camera device operations handle shared by all devices. The operation of one
+// device are called on the same mojo thread. The operations of two different
+// devices are called on two different mojo threads.
+extern camera3_device_ops_t g_camera_device_ops;
+
+}  // namespace arc
+
+#endif  // USB_CAMERA_HAL_DEVICE_OPS_H_
diff --git a/usb/common.h b/usb/common.h
new file mode 100644
index 0000000..4732329
--- /dev/null
+++ b/usb/common.h
@@ -0,0 +1,18 @@
+/* Copyright 2016 The Chromium OS Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef USB_COMMON_H_
+#define USB_COMMON_H_
+
+#include <base/logging.h>
+
+#define LOGF(level) LOG(level) << __FUNCTION__ << "(): "
+#define LOGFID(level, id) LOG(level) << __FUNCTION__ << "(): id: " << id << ": "
+
+#define VLOGF(level) VLOG(level) << __FUNCTION__ << "(): "
+#define VLOGFID(level, id) \
+  VLOG(level) << __FUNCTION__ << "(): id: " << id << ": "
+
+#endif  // USB_COMMON_H_
diff --git a/usb/common.mk b/usb/common.mk
new file mode 100644
index 0000000..ac8c7fc
--- /dev/null
+++ b/usb/common.mk
@@ -0,0 +1,941 @@
+# Copyright 2012 The Chromium OS Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+#
+# If this file is part of another source distribution, it's license may be
+# stored in LICENSE.makefile or LICENSE.common.mk.
+#
+# NOTE NOTE NOTE
+#  The authoritative common.mk is located in:
+#    https://chromium.googlesource.com/chromiumos/platform2/+/master/common-mk
+#  Please make all changes there, then copy into place in other repos.
+# NOTE NOTE NOTE
+#
+# This file provides a common architecture for building C/C++ source trees.
+# It uses recursive makefile inclusion to create a single make process which
+# can be built in the source tree or with the build artifacts placed elsewhere.
+#
+# It is fully parallelizable for all targets, including static archives.
+#
+# To use:
+# 1. Place common.mk in your top source level
+# 2. In your top-level Makefile, place "include common.mk" at the top
+# 3. In all subdirectories, create a 'module.mk' file that starts with:
+#      include common.mk
+#    And then contains the remainder of your targets.
+# 4. All build targets should look like:
+#    relative/path/target: relative/path/obj.o
+#
+# See existing makefiles for rule examples.
+#
+# Exported macros:
+#   - cc_binary, cxx_binary provide standard compilation steps for binaries
+#   - cxx_library, cc_library provide standard compilation steps for
+#     shared objects.
+#   All of the above optionally take an argument for extra flags.
+#   - update_archive creates/updates a given .a target
+#
+# Instead of using the build macros, most users can just use wrapped targets:
+#   - CXX_BINARY, CC_BINARY, CC_STATIC_BINARY, CXX_STATIC_BINARY
+#   - CXX_LIBRARY, CC_LIBRARY, CC_STATIC_LIBRARY, CXX_STATIC_LIBRARY
+#   - E.g., CXX_BINARY(mahbinary): foo.o
+#   - object.depends targets may be used when a prerequisite is required for an
+#     object file. Because object files result in multiple build artifacts to
+#     handle PIC and PIE weirdness. E.g.
+#       foo.o.depends: generated/dbus.h
+#   - TEST(binary) or TEST(CXX_BINARY(binary)) may be used as a prerequisite
+#     for the tests target to trigger an automated test run.
+#   - CLEAN(file_or_dir) dependency can be added to 'clean'.
+#
+# If source code is being generated, rules will need to be registered for
+# compiling the objects.  This can be done by adding one of the following
+# to the Makefile:
+#   - For C source files
+#   $(eval $(call add_object_rules,sub/dir/gen_a.o sub/dir/b.o,CC,c,CFLAGS))
+#   - For C++ source files
+#   $(eval $(call add_object_rules,sub/dir/gen_a.o sub/dir/b.o,CXX,cc,CXXFLAGS))
+#
+# Exported targets meant to have prerequisites added to:
+#  - all - Your desired targets should be given
+#  - tests - Any TEST(test_binary) targets should be given
+#  - FORCE - force the given target to run regardless of changes
+#            In most cases, using .PHONY is preferred.
+#
+# Possible command line variables:
+#   - COLOR=[0|1] to set ANSI color output (default: 1)
+#   - VERBOSE=[0|1] to hide/show commands (default: 0)
+#   - MODE=[opt|dbg|profiling] (default: opt)
+#          opt - Enable optimizations for release builds
+#          dbg - Turn down optimization for debugging
+#          profiling - Turn off optimization and turn on profiling/coverage
+#                      support.
+#   - ARCH=[x86|arm|supported qemu name] (default: from portage or uname -m)
+#   - SPLITDEBUG=[0|1] splits debug info in target.debug (default: 0)
+#        If NOSTRIP=1, SPLITDEBUG will never strip the final emitted objects.
+#   - NOSTRIP=[0|1] determines if binaries are stripped. (default: 1)
+#        NOSTRIP=0 and MODE=opt will also drop -g from the CFLAGS.
+#   - VALGRIND=[0|1] runs tests under valgrind (default: 0)
+#   - OUT=/path/to/builddir puts all output in given path (default: $PWD)
+#   - VALGRIND_ARGS="" supplies extra memcheck arguments
+#
+# Per-target(-ish) variable:
+#   - NEEDS_ROOT=[0|1] allows a TEST() target to run with root.
+#     Default is 0 unless it is running under QEmu.
+#   - NEEDS_MOUNTS=[0|1] allows a TEST() target running on QEmu to get
+#     setup mounts in the $(SYSROOT)
+#
+# Caveats:
+# - Directories or files with spaces in them DO NOT get along with GNU Make.
+#   If you need them, all uses of dir/notdir/etc will need to have magic
+#   wrappers.  Proceed at risk to your own sanity.
+# - External CXXFLAGS and CFLAGS should be passed via the environment since
+#   this file does not use 'override' to control them.
+# - Our version of GNU Make doesn't seem to support the 'private' variable
+#   annotation, so you can't tag a variable private on a wrapping target.
+
+# Behavior configuration variables
+SPLITDEBUG ?= 0
+NOSTRIP ?= 1
+VALGRIND ?= 0
+COLOR ?= 1
+VERBOSE ?= 0
+MODE ?= opt
+CXXEXCEPTIONS ?= 0
+ARCH ?= $(shell uname -m)
+
+# Put objects in a separate tree based on makefile locations
+# This means you can build a tree without touching it:
+#   make -C $SRCDIR  # will create ./build-$(MODE)
+# Or
+#   make -C $SRCDIR OUT=$PWD
+# This variable is extended on subdir calls and doesn't need to be re-called.
+OUT ?= $(PWD)/
+
+# Make OUT now so we can use realpath.
+$(shell mkdir -p "$(OUT)")
+
+# TODO(wad) Relative paths are resolved against SRC and not the calling dir.
+# Ensure a command-line supplied OUT has a slash
+override OUT := $(realpath $(OUT))/
+
+# SRC is not meant to be set by the end user, but during make call relocation.
+# $(PWD) != $(CURDIR) all the time.
+export SRC ?= $(CURDIR)
+
+# If BASE_VER is not set, read the libchrome revision number from
+# common-mk/BASE_VER file.
+ifeq ($(strip $(BASE_VER)),)
+BASE_VER := $(shell cat $(SRC)/../common-mk/BASE_VER)
+endif
+$(info Using BASE_VER=$(BASE_VER))
+
+# Re-start in the $(OUT) directory if we're not there.
+# We may be invoked using -C or bare and we need to ensure behavior
+# is consistent so we check both PWD vs OUT and PWD vs CURDIR.
+override RELOCATE_BUILD := 0
+ifneq (${PWD}/,${OUT})
+override RELOCATE_BUILD := 1
+endif
+# Make sure we're running with no builtin targets. They cause
+# leakage and mayhem!
+ifneq (${PWD},${CURDIR})
+override RELOCATE_BUILD := 1
+# If we're run from the build dir, don't let it get cleaned up later.
+ifeq (${PWD}/,${OUT})
+$(shell touch "$(PWD)/.dont_delete_on_clean")
+endif
+endif  # ifneq (${PWD},${CURDIR}
+
+# "Relocate" if we need to restart without implicit rules.
+ifeq ($(subst r,,$(MAKEFLAGS)),$(MAKEFLAGS))
+override RELOCATE_BUILD := 1
+endif
+
+ifeq (${RELOCATE_BUILD},1)
+# By default, silence build output. Reused below as well.
+QUIET = @
+ifeq ($(VERBOSE),1)
+  QUIET=
+endif
+
+# This target will override all targets, including prerequisites. To avoid
+# calling $(MAKE) once per prereq on the given CMDGOAL, we guard it with a local
+# variable.
+RUN_ONCE := 0
+MAKECMDGOALS ?= all
+# Keep the rules split as newer make does not allow them to be declared
+# on the same line.  But the way :: rules work, the _all here will also
+# invoke the %:: rule while retaining "_all" as the default.
+_all::
+%::
+	$(if $(filter 0,$(RUN_ONCE)), \
+	  cd "$(OUT)" && \
+	  $(MAKE) -r -I "$(SRC)" -f "$(CURDIR)/Makefile" \
+	    SRC="$(CURDIR)" OUT="$(OUT)" $(foreach g,$(MAKECMDGOALS),"$(g)"),)
+	$(eval RUN_ONCE := 1)
+pass-to-subcall := 1
+endif
+
+ifeq ($(pass-to-subcall),)
+
+# Only call MODULE if we're in a submodule
+MODULES_LIST := $(filter-out Makefile %.d,$(MAKEFILE_LIST))
+ifeq ($(words $(filter-out Makefile common.mk %.d $(SRC)/Makefile \
+                           $(SRC)/common.mk,$(MAKEFILE_LIST))),0)
+
+# All the top-level defines outside of module.mk.
+
+#
+# Helper macros
+#
+
+# Create the directory if it doesn't yet exist.
+define auto_mkdir
+  $(if $(wildcard $(dir $1)),$2,$(QUIET)mkdir -p "$(dir $1)")
+endef
+
+# Creates the actual archive with an index.
+# The target $@ must end with .pic.a or .pie.a.
+define update_archive
+  $(call auto_mkdir,$(TARGET_OR_MEMBER))
+  $(QUIET)# Create the archive in one step to avoid parallel use accessing it
+  $(QUIET)# before all the symbols are present.
+  @$(ECHO) "AR		$(subst \
+$(SRC)/,,$(^:.o=$(suffix $(basename $(TARGET_OR_MEMBER))).o)) \
+-> $(subst $(SRC)/,,$(TARGET_OR_MEMBER))"
+  $(QUIET)$(AR) rcs $(TARGET_OR_MEMBER) \
+          $(subst $(SRC)/,,$(^:.o=$(suffix $(basename $(TARGET_OR_MEMBER))).o))
+endef
+
+# Default compile from objects using pre-requisites but filters out
+# subdirs and .d files.
+define cc_binary
+  $(call COMPILE_BINARY_implementation,CC,$(CFLAGS) $(1),$(EXTRA_FLAGS))
+endef
+
+define cxx_binary
+  $(call COMPILE_BINARY_implementation,CXX,$(CXXFLAGS) $(1),$(EXTRA_FLAGS))
+endef
+
+# Default compile from objects using pre-requisites but filters out
+# subdirs and .d files.
+define cc_library
+  $(call COMPILE_LIBRARY_implementation,CC,$(CFLAGS) $(1),$(EXTRA_FLAGS))
+endef
+define cxx_library
+  $(call COMPILE_LIBRARY_implementation,CXX,$(CXXFLAGS) $(1),$(EXTRA_FLAGS))
+endef
+
+# Deletes files silently if they exist. Meant for use in any local
+# clean targets.
+define silent_rm
+  $(if $(wildcard $(1)),
+  $(QUIET)($(ECHO) -n '$(COLOR_RED)CLEANFILE$(COLOR_RESET)		' && \
+    $(ECHO) '$(subst $(OUT)/,,$(wildcard $(1)))' && \
+    $(RM) $(1) 2>/dev/null) || true,)
+endef
+define silent_rmdir
+  $(if $(wildcard $(1)),
+    $(if $(wildcard $(1)/*),
+  $(QUIET)# $(1) not empty [$(wildcard $(1)/*)]. Not deleting.,
+  $(QUIET)($(ECHO) -n '$(COLOR_RED)CLEANDIR$(COLOR_RESET)		' && \
+    $(ECHO) '$(subst $(OUT)/,,$(wildcard $(1)))' && \
+    $(RMDIR) $(1) 2>/dev/null) || true),)
+endef
+
+#
+# Default variable values
+#
+
+# Only override toolchain vars if they are from make.
+CROSS_COMPILE ?=
+define override_var
+ifneq ($(filter undefined default,$(origin $1)),)
+$1 = $(CROSS_COMPILE)$2
+endif
+endef
+$(eval $(call override_var,AR,ar))
+$(eval $(call override_var,CC,gcc))
+$(eval $(call override_var,CXX,g++))
+$(eval $(call override_var,OBJCOPY,objcopy))
+$(eval $(call override_var,PKG_CONFIG,pkg-config))
+$(eval $(call override_var,RANLIB,ranlib))
+$(eval $(call override_var,STRIP,strip))
+
+RMDIR ?= rmdir
+ECHO = /bin/echo -e
+
+ifeq ($(lastword $(subst /, ,$(CC))),clang)
+CDRIVER = clang
+else
+CDRIVER = gcc
+endif
+
+ifeq ($(lastword $(subst /, ,$(CXX))),clang++)
+CXXDRIVER = clang
+else
+CXXDRIVER = gcc
+endif
+
+# Internal macro to support check_XXX macros below.
+# Usage: $(call check_compile, [code], [compiler], [code_type], [c_flags],
+#               [extra_c_flags], [library_flags], [success_ret], [fail_ret])
+# Return: [success_ret] if compile succeeded, otherwise [fail_ret]
+check_compile = $(shell printf '%b\n' $(1) | \
+  $($(2)) $($(4)) -x $(3) $(LDFLAGS) $(5) - $(6) -o /dev/null > /dev/null 2>&1 \
+  && echo "$(7)" || echo "$(8)")
+
+# Helper macro to check whether a test program will compile with the specified
+# compiler flags.
+# Usage: $(call check_compile_cc, [code], [flags], [alternate_flags])
+# Return: [flags] if compile succeeded, otherwise [alternate_flags]
+check_compile_cc = $(call check_compile,$(1),CC,c,CFLAGS,$(2),,$(2),$(3))
+check_compile_cxx = $(call check_compile,$(1),CXX,c++,CXXFLAGS,$(2),,$(2),$(3))
+
+# Helper macro to check whether a test program will compile with the specified
+# libraries.
+# Usage: $(call check_compile_cc, [code], [library_flags], [alternate_flags])
+# Return: [library_flags] if compile succeeded, otherwise [alternate_flags]
+check_libs_cc = $(call check_compile,$(1),CC,c,CFLAGS,,$(2),$(2),$(3))
+check_libs_cxx = $(call check_compile,$(1),CXX,c++,CXXFLAGS,,$(2),$(2),$(3))
+
+# Helper macro to check whether the compiler accepts the specified flags.
+# Usage: $(call check_compile_cc, [flags], [alternate_flags])
+# Return: [flags] if compile succeeded, otherwise [alternate_flags]
+check_cc = $(call check_compile_cc,'int main() { return 0; }',$(1),$(2))
+check_cxx = $(call check_compile_cxx,'int main() { return 0; }',$(1),$(2))
+
+# Choose the stack protector flags based on whats supported by the compiler.
+SSP_CFLAGS := $(call check_cc,-fstack-protector-strong)
+ifeq ($(SSP_CFLAGS),)
+ SSP_CFLAGS := $(call check_cc,-fstack-protector-all)
+endif
+
+# To update these from an including Makefile:
+#  CXXFLAGS += -mahflag  # Append to the list
+#  CXXFLAGS := -mahflag $(CXXFLAGS) # Prepend to the list
+#  CXXFLAGS := $(filter-out badflag,$(CXXFLAGS)) # Filter out a value
+# The same goes for CFLAGS.
+COMMON_CFLAGS-gcc := -fvisibility=internal -ggdb3 -Wa,--noexecstack
+COMMON_CFLAGS-clang := -fvisibility=hidden -ggdb
+COMMON_CFLAGS := -Wall -Werror -fno-strict-aliasing $(SSP_CFLAGS) -O1 -Wformat=2
+CXXFLAGS += $(COMMON_CFLAGS) $(COMMON_CFLAGS-$(CXXDRIVER))
+CFLAGS += $(COMMON_CFLAGS) $(COMMON_CFLAGS-$(CDRIVER))
+CPPFLAGS += -D_FORTIFY_SOURCE=2
+
+# Enable large file support.
+CPPFLAGS += -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE
+
+# Disable exceptions based on the CXXEXCEPTIONS setting.
+ifeq ($(CXXEXCEPTIONS),0)
+  CXXFLAGS := $(CXXFLAGS) -fno-exceptions -fno-unwind-tables \
+    -fno-asynchronous-unwind-tables
+endif
+
+ifeq ($(MODE),opt)
+  # Up the optimizations.
+  CFLAGS := $(filter-out -O1,$(CFLAGS)) -O2
+  CXXFLAGS := $(filter-out -O1,$(CXXFLAGS)) -O2
+  # Only drop -g* if symbols aren't desired.
+  ifeq ($(NOSTRIP),0)
+    # TODO: do we want -fomit-frame-pointer on x86?
+    CFLAGS := $(filter-out -ggdb3,$(CFLAGS))
+    CXXFLAGS := $(filter-out -ggdb3,$(CXXFLAGS))
+  endif
+endif
+
+ifeq ($(MODE),profiling)
+  CFLAGS := $(CFLAGS) -O0 -g  --coverage
+  CXXFLAGS := $(CXXFLAGS) -O0 -g  --coverage
+  LDFLAGS := $(LDFLAGS) --coverage
+endif
+
+LDFLAGS := $(LDFLAGS) -Wl,-z,relro -Wl,-z,noexecstack -Wl,-z,now
+
+# Fancy helpers for color if a prompt is defined
+ifeq ($(COLOR),1)
+COLOR_RESET = \x1b[0m
+COLOR_GREEN = \x1b[32;01m
+COLOR_RED = \x1b[31;01m
+COLOR_YELLOW = \x1b[33;01m
+endif
+
+# By default, silence build output.
+QUIET = @
+ifeq ($(VERBOSE),1)
+  QUIET=
+endif
+
+#
+# Implementation macros for compile helpers above
+#
+
+# Useful for dealing with pie-broken toolchains.
+# Call make with PIE=0 to disable default PIE use.
+OBJ_PIE_FLAG = -fPIE
+COMPILE_PIE_FLAG = -pie
+ifeq ($(PIE),0)
+  OBJ_PIE_FLAG =
+  COMPILE_PIE_FLAG =
+endif
+
+# Favor member targets first for CXX_BINARY(%) magic.
+# And strip out nested members if possible.
+LP := (
+RP := )
+TARGET_OR_MEMBER = $(lastword $(subst $(LP), ,$(subst $(RP),,$(or $%,$@))))
+
+# Default compile from objects using pre-requisites but filters out
+# all non-.o files.
+define COMPILE_BINARY_implementation
+  @$(ECHO) "LD$(1)		$(subst $(PWD)/,,$(TARGET_OR_MEMBER))"
+  $(call auto_mkdir,$(TARGET_OR_MEMBER))
+  $(QUIET)$($(1)) $(COMPILE_PIE_FLAGS) -o $(TARGET_OR_MEMBER) \
+    $(2) $(LDFLAGS) \
+    $(filter %.o %.a,$(^:.o=.pie.o)) \
+    $(foreach so,$(filter %.so,$^),-L$(dir $(so)) \
+                            -l$(patsubst lib%,%,$(basename $(notdir $(so))))) \
+    $(LDLIBS)
+  $(call conditional_strip)
+  @$(ECHO) -n "BIN		"
+  @$(ECHO) "$(COLOR_GREEN)$(subst $(PWD)/,,$(TARGET_OR_MEMBER))$(COLOR_RESET)"
+  @$(ECHO) "	$(COLOR_YELLOW)-----$(COLOR_RESET)"
+endef
+
+# TODO: add version support extracted from PV environment variable
+#ifeq ($(PV),9999)
+#$(warning PV=$(PV). If shared object versions matter, please force PV=.)
+#endif
+# Then add -Wl,-soname,$@.$(PV) ?
+
+# Default compile from objects using pre-requisites but filters out
+# all non-.o values. (Remember to add -L$(OUT) -llib)
+COMMA := ,
+define COMPILE_LIBRARY_implementation
+  @$(ECHO) "SHARED$(1)	$(subst $(PWD)/,,$(TARGET_OR_MEMBER))"
+  $(call auto_mkdir,$(TARGET_OR_MEMBER))
+  $(QUIET)$($(1)) -shared -Wl,-E -o $(TARGET_OR_MEMBER) \
+    $(2) $(LDFLAGS) \
+    $(if $(filter %.a,$^),-Wl$(COMMA)--whole-archive,) \
+    $(filter %.o ,$(^:.o=.pic.o)) \
+    $(foreach a,$(filter %.a,$^),-L$(dir $(a)) \
+                            -l$(patsubst lib%,%,$(basename $(notdir $(a))))) \
+    $(foreach so,$(filter %.so,$^),-L$(dir $(so)) \
+                            -l$(patsubst lib%,%,$(basename $(notdir $(so))))) \
+    $(LDLIBS)
+  $(call conditional_strip)
+  @$(ECHO) -n "LIB		$(COLOR_GREEN)"
+  @$(ECHO) "$(subst $(PWD)/,,$(TARGET_OR_MEMBER))$(COLOR_RESET)"
+  @$(ECHO) "	$(COLOR_YELLOW)-----$(COLOR_RESET)"
+endef
+
+define conditional_strip
+  $(if $(filter 0,$(NOSTRIP)),$(call strip_artifact))
+endef
+
+define strip_artifact
+  @$(ECHO) "STRIP		$(subst $(OUT)/,,$(TARGET_OR_MEMBER))"
+  $(if $(filter 1,$(SPLITDEBUG)), @$(ECHO) -n "DEBUG	"; \
+    $(ECHO) "$(COLOR_YELLOW)\
+$(subst $(OUT)/,,$(TARGET_OR_MEMBER)).debug$(COLOR_RESET)")
+  $(if $(filter 1,$(SPLITDEBUG)), \
+    $(QUIET)$(OBJCOPY) --only-keep-debug "$(TARGET_OR_MEMBER)" \
+      "$(TARGET_OR_MEMBER).debug")
+  $(if $(filter-out dbg,$(MODE)),$(QUIET)$(STRIP) --strip-unneeded \
+    "$(TARGET_OR_MEMBER)",)
+endef
+
+#
+# Global pattern rules
+#
+
+# Below, the archive member syntax is abused to create fancier
+# syntactic sugar for recipe authors that avoids needed to know
+# subcall options.  The downside is that make attempts to look
+# into the phony archives for timestamps. This will cause the final
+# target to be rebuilt/linked on _every_ call to make even when nothing
+# has changed.  Until a better way presents itself, we have helpers that
+# do the stat check on make's behalf.  Dodgy but simple.
+define old_or_no_timestamp
+  $(if $(realpath $%),,$(1))
+  $(if $(shell find $^ -cnewer "$%" 2>/dev/null),$(1))
+endef
+
+define check_deps
+  $(if $(filter 0,$(words $^)),\
+    $(error Missing dependencies or declaration of $@($%)),)
+endef
+
+# Build a cxx target magically
+CXX_BINARY(%):
+	$(call check_deps)
+	$(call old_or_no_timestamp,$(call cxx_binary))
+clean: CLEAN(CXX_BINARY*)
+
+CC_BINARY(%):
+	$(call check_deps)
+	$(call old_or_no_timestamp,$(call cc_binary))
+clean: CLEAN(CC_BINARY*)
+
+CXX_STATIC_BINARY(%):
+	$(call check_deps)
+	$(call old_or_no_timestamp,$(call cxx_binary,-static))
+clean: CLEAN(CXX_STATIC_BINARY*)
+
+CC_STATIC_BINARY(%):
+	$(call check_deps)
+	$(call old_or_no_timestamp,$(call cc_binary,-static))
+clean: CLEAN(CC_STATIC_BINARY*)
+
+CXX_LIBRARY(%):
+	$(call check_deps)
+	$(call old_or_no_timestamp,$(call cxx_library))
+clean: CLEAN(CXX_LIBRARY*)
+
+CXX_LIBARY(%):
+	$(error Typo alert! LIBARY != LIBRARY)
+
+CC_LIBRARY(%):
+	$(call check_deps)
+	$(call old_or_no_timestamp,$(call cc_library))
+clean: CLEAN(CC_LIBRARY*)
+
+CC_LIBARY(%):
+	$(error Typo alert! LIBARY != LIBRARY)
+
+CXX_STATIC_LIBRARY(%):
+	$(call check_deps)
+	$(call old_or_no_timestamp,$(call update_archive))
+clean: CLEAN(CXX_STATIC_LIBRARY*)
+
+CXX_STATIC_LIBARY(%):
+	$(error Typo alert! LIBARY != LIBRARY)
+
+CC_STATIC_LIBRARY(%):
+	$(call check_deps)
+	$(call old_or_no_timestamp,$(call update_archive))
+clean: CLEAN(CC_STATIC_LIBRARY*)
+
+CC_STATIC_LIBARY(%):
+	$(error Typo alert! LIBARY != LIBRARY)
+
+
+TEST(%): % qemu_chroot_install
+	$(call TEST_implementation)
+.PHONY: TEST
+
+# multiple targets with a wildcard need to share an directory.
+# Don't use this directly it just makes sure the directory is removed _after_
+# the files are.
+CLEANFILE(%):
+	$(call silent_rm,$(TARGET_OR_MEMBER))
+.PHONY: CLEANFILE
+
+CLEAN(%): CLEANFILE(%)
+	$(QUIET)# CLEAN($%) meta-target called
+	$(if $(filter-out $(PWD)/,$(dir $(abspath $(TARGET_OR_MEMBER)))), \
+	  $(call silent_rmdir,$(dir $(abspath $(TARGET_OR_MEMBER)))),\
+	  $(QUIET)# Not deleting $(dir $(abspath $(TARGET_OR_MEMBER))) yet.)
+.PHONY: CLEAN
+
+#
+# Top-level objects and pattern rules
+#
+
+# All objects for .c files at the top level
+C_OBJECTS = $(patsubst $(SRC)/%.c,%.o,$(wildcard $(SRC)/*.c))
+
+
+# All objects for .cxx files at the top level
+CXX_OBJECTS = $(patsubst $(SRC)/%.cc,%.o,$(wildcard $(SRC)/*.cc))
+
+# Note, the catch-all pattern rules don't work in subdirectories because
+# we're building from the $(OUT) directory. At the top-level (here) they will
+# work, but we go ahead and match using the module form.  Then we can place a
+# generic pattern rule to capture leakage from the main Makefile. (Later in the
+# file.)
+#
+# The reason target specific pattern rules work well for modules,
+# MODULE_C_OBJECTS, is because it scopes the behavior to the given target which
+# ensures we get a relative directory offset from $(OUT) which otherwise would
+# not match without further magic on a per-subdirectory basis.
+
+# Creates object file rules. Call with eval.
+# $(1) list of .o files
+# $(2) source type (CC or CXX)
+# $(3) source suffix (cc or c)
+# $(4) compiler flag name (CFLAGS or CXXFLAGS)
+# $(5) source dir: _only_ if $(SRC). Leave blank for obj tree.
+define add_object_rules
+$(patsubst %.o,%.pie.o,$(1)): %.pie.o: $(5)%.$(3) %.o.depends
+	$$(call auto_mkdir,$$@)
+	$$(call OBJECT_PATTERN_implementation,$(2),\
+          $$(basename $$@),$$($(4)) $$(CPPFLAGS) $$(OBJ_PIE_FLAG))
+
+$(patsubst %.o,%.pic.o,$(1)): %.pic.o: $(5)%.$(3) %.o.depends
+	$$(call auto_mkdir,$$@)
+	$$(call OBJECT_PATTERN_implementation,$(2),\
+          $$(basename $$@),$$($(4)) $$(CPPFLAGS) -fPIC)
+
+# Placeholder for depends
+$(patsubst %.o,%.o.depends,$(1)):
+	$$(call auto_mkdir,$$@)
+	$$(QUIET)touch "$$@"
+
+$(1): %.o: %.pic.o %.pie.o
+	$$(call auto_mkdir,$$@)
+	$$(QUIET)touch "$$@"
+endef
+
+define OBJECT_PATTERN_implementation
+  @$(ECHO) "$(1)		$(subst $(SRC)/,,$<) -> $(2).o"
+  $(call auto_mkdir,$@)
+  $(QUIET)$($(1)) -c -MD -MF $(2).d $(3) -o $(2).o $<
+  $(QUIET)# Wrap all the deps in $$(wildcard) so a missing header
+  $(QUIET)# won't cause weirdness.  First we remove newlines and \,
+  $(QUIET)# then wrap it.
+  $(QUIET)sed -i -e :j -e '$$!N;s|\\\s*\n| |;tj' \
+    -e 's|^\(.*\s*:\s*\)\(.*\)$$|\1 $$\(wildcard \2\)|' $(2).d
+endef
+
+# Now actually register handlers for C(XX)_OBJECTS.
+$(eval $(call add_object_rules,$(C_OBJECTS),CC,c,CFLAGS,$(SRC)/))
+$(eval $(call add_object_rules,$(CXX_OBJECTS),CXX,cc,CXXFLAGS,$(SRC)/))
+
+# Disable default pattern rules to help avoid leakage.
+# These may already be handled by '-r', but let's keep it to be safe.
+%: %.o ;
+%.a: %.o ;
+%.o: %.c ;
+%.o: %.cc ;
+
+# NOTE: A specific rule for archive objects is avoided because parallel
+#       update of the archive causes build flakiness.
+# Instead, just make the objects the prerequisites and use update_archive
+# To use the foo.a(obj.o) functionality, targets would need to specify the
+# explicit object they expect on the prerequisite line.
+
+#
+# Architecture detection and QEMU wrapping
+#
+
+HOST_ARCH ?= $(shell uname -m)
+override ARCH := $(strip $(ARCH))
+override HOST_ARCH := $(strip $(HOST_ARCH))
+# emake will supply "x86" or "arm" for ARCH, but
+# if uname -m runs and you get x86_64, then this subst
+# will break.
+ifeq ($(subst x86,i386,$(ARCH)),i386)
+  QEMU_ARCH := $(subst x86,i386,$(ARCH))  # x86 -> i386
+else ifeq ($(subst amd64,x86_64,$(ARCH)),x86_64)
+  QEMU_ARCH := $(subst amd64,x86_64,$(ARCH))  # amd64 -> x86_64
+else
+  QEMU_ARCH = $(ARCH)
+endif
+override QEMU_ARCH := $(strip $(QEMU_ARCH))
+
+# If we're cross-compiling, try to use qemu for running the tests.
+ifneq ($(QEMU_ARCH),$(HOST_ARCH))
+  ifeq ($(SYSROOT),)
+    $(info SYSROOT not defined. qemu-based testing disabled)
+  else
+    # A SYSROOT is assumed for QEmu use.
+    USE_QEMU ?= 1
+
+    # Allow 64-bit hosts to run 32-bit without qemu.
+    ifeq ($(HOST_ARCH),x86_64)
+      ifeq ($(QEMU_ARCH),i386)
+        USE_QEMU = 0
+      endif
+    endif
+  endif
+else
+  USE_QEMU ?= 0
+endif
+
+# Normally we don't need to run as root or do bind mounts, so only
+# enable it by default when we're using QEMU.
+NEEDS_ROOT ?= $(USE_QEMU)
+NEEDS_MOUNTS ?= $(USE_QEMU)
+
+SYSROOT_OUT = $(OUT)
+ifneq ($(SYSROOT),)
+  SYSROOT_OUT = $(subst $(SYSROOT),,$(OUT))
+else
+  # Default to / when all the empty-sysroot logic is done.
+  SYSROOT = /
+endif
+
+QEMU_NAME = qemu-$(QEMU_ARCH)
+QEMU_PATH = /build/bin/$(QEMU_NAME)
+QEMU_SYSROOT_PATH = $(SYSROOT)$(QEMU_PATH)
+QEMU_SRC_PATH = /usr/bin/$(QEMU_NAME)
+QEMU_BINFMT_PATH = /proc/sys/fs/binfmt_misc/$(QEMU_NAME)
+QEMU_REGISTER_PATH = /proc/sys/fs/binfmt_misc/register
+
+QEMU_MAGIC_arm = ":$(QEMU_NAME):M::\x7fELF\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x28\x00:\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:/build/bin/qemu-arm:"
+
+
+#
+# Output full configuration at top level
+#
+
+# Don't show on clean
+ifneq ($(MAKECMDGOALS),clean)
+  $(info build configuration:)
+  $(info - OUT=$(OUT))
+  $(info - SRC=$(SRC))
+  $(info - MODE=$(MODE))
+  $(info - SPLITDEBUG=$(SPLITDEBUG))
+  $(info - NOSTRIP=$(NOSTRIP))
+  $(info - VALGRIND=$(VALGRIND))
+  $(info - COLOR=$(COLOR))
+  $(info - CXXEXCEPTIONS=$(CXXEXCEPTIONS))
+  $(info - ARCH=$(ARCH))
+  $(info - QEMU_ARCH=$(QEMU_ARCH))
+  $(info - USE_QEMU=$(USE_QEMU))
+  $(info - NEEDS_ROOT=$(NEEDS_ROOT))
+  $(info - NEEDS_MOUNTS=$(NEEDS_MOUNTS))
+  $(info - SYSROOT=$(SYSROOT))
+  $(info )
+endif
+
+#
+# Standard targets with detection for when they are improperly configured.
+#
+
+# all does not include tests by default
+all:
+	$(QUIET)(test -z "$^" && \
+	$(ECHO) "You must add your targets as 'all' prerequisites") || true
+	$(QUIET)test -n "$^"
+
+# Builds and runs tests for the target arch
+# Run them in parallel
+# After the test have completed, if profiling, run coverage analysis
+tests:
+ifeq ($(MODE),profiling)
+	@$(ECHO) "COVERAGE [$(COLOR_YELLOW)STARTED$(COLOR_RESET)]"
+	$(QUIET)FILES="";						\
+		for GCNO in `find . -name "*.gcno"`; do			\
+			GCDA="$${GCNO%.gcno}.gcda";			\
+			if [ -e $${GCDA} ]; then			\
+				FILES="$${FILES} $${GCDA}";		\
+			fi						\
+		done;							\
+		if [ -n "$${FILES}" ]; then				\
+			gcov -l $${FILES};				\
+			lcov --capture --directory .			\
+				--output-file=lcov-coverage.info;	\
+			genhtml lcov-coverage.info			\
+				--output-directory lcov-html;		\
+		fi
+	@$(ECHO) "COVERAGE [$(COLOR_YELLOW)FINISHED$(COLOR_RESET)]"
+endif
+.PHONY: tests
+
+qemu_chroot_install:
+ifeq ($(USE_QEMU),1)
+	$(QUIET)$(ECHO) "QEMU   Preparing $(QEMU_NAME)"
+	@# Copying strategy
+	@# Compare /usr/bin/qemu inode to /build/$board/build/bin/qemu, if different
+	@# hard link to a temporary file, then rename temp to target. This should
+	@# ensure that once $QEMU_SYSROOT_PATH exists it will always exist, regardless
+	@# of simultaneous test setups.
+	$(QUIET)if [[ ! -e $(QEMU_SYSROOT_PATH) || \
+	    `stat -c %i $(QEMU_SRC_PATH)` != `stat -c %i $(QEMU_SYSROOT_PATH)` \
+	    ]]; then \
+	  $(ROOT_CMD) ln -Tf $(QEMU_SRC_PATH) $(QEMU_SYSROOT_PATH).$$$$; \
+	  $(ROOT_CMD) mv -Tf $(QEMU_SYSROOT_PATH).$$$$ $(QEMU_SYSROOT_PATH); \
+	fi
+
+	@# Prep the binfmt handler. First mount if needed, then unregister any bad
+	@# mappings and then register our mapping.
+	@# There may still be some race conditions here where one script de-registers
+	@# and another script starts executing before it gets re-registered, however
+	@# it should be rare.
+	-$(QUIET)[[ -e $(QEMU_REGISTER_PATH) ]] || \
+	  $(ROOT_CMD) mount binfmt_misc -t binfmt_misc \
+	    /proc/sys/fs/binfmt_misc
+
+	-$(QUIET)if [[ -e $(QEMU_BINFMT_PATH) && \
+	      `awk '$$1 == "interpreter" {print $$NF}' $(QEMU_BINFMT_PATH)` != \
+	      "$(QEMU_PATH)" ]]; then \
+	  echo -1 | $(ROOT_CMD) tee $(QEMU_BINFMT_PATH) >/dev/null; \
+	fi
+
+	-$(if $(QEMU_MAGIC_$(ARCH)),$(QUIET)[[ -e $(QEMU_BINFMT_PATH) ]] || \
+	  echo $(QEMU_MAGIC_$(ARCH)) | $(ROOT_CMD) tee $(QEMU_REGISTER_PATH) \
+	    >/dev/null)
+endif
+.PHONY: qemu_clean qemu_chroot_install
+
+# TODO(wad) Move to -L $(SYSROOT) and fakechroot when qemu-user
+#           doesn't hang traversing /proc from SYSROOT.
+SUDO_CMD = sudo
+UNSHARE_CMD = unshare
+QEMU_CMD =
+ROOT_CMD = $(if $(filter 1,$(NEEDS_ROOT)),$(SUDO_CMD) , )
+MOUNT_CMD = $(if $(filter 1,$(NEEDS_MOUNTS)),$(ROOT_CMD) mount, \#)
+UMOUNT_CMD = $(if $(filter 1,$(NEEDS_MOUNTS)),$(ROOT_CMD) umount, \#)
+QEMU_LDPATH = $(SYSROOT_LDPATH):/lib64:/lib:/usr/lib64:/usr/lib
+ROOT_CMD_LDPATH = $(SYSROOT_LDPATH):$(SYSROOT)/lib64:
+ROOT_CMD_LDPATH := $(ROOT_CMD_LDPATH):$(SYSROOT)/lib:$(SYSROOT)/usr/lib64:
+ROOT_CMD_LDPATH := $(ROOT_CMD_LDPATH):$(SYSROOT)/usr/lib
+ifeq ($(USE_QEMU),1)
+  export QEMU_CMD = \
+   $(SUDO_CMD) chroot $(SYSROOT) $(QEMU_PATH) \
+   -drop-ld-preload \
+   -E LD_LIBRARY_PATH="$(QEMU_LDPATH):$(patsubst $(OUT),,$(LD_DIRS))" \
+   -E HOME="$(HOME)" -E SRC="$(SRC)" --
+  # USE_QEMU conditional function
+  define if_qemu
+    $(1)
+  endef
+else
+  ROOT_CMD = $(if $(filter 1,$(NEEDS_ROOT)),sudo, ) \
+    LD_LIBRARY_PATH="$(ROOT_CMD_LDPATH):$(LD_DIRS)"
+  define if_qemu
+    $(2)
+  endef
+endif
+
+VALGRIND_CMD =
+ifeq ($(VALGRIND),1)
+  VALGRIND_CMD = /usr/bin/valgrind --tool=memcheck $(VALGRIND_ARGS) --
+endif
+
+define TEST_implementation
+  $(QUIET)$(call TEST_setup)
+  $(QUIET)$(call TEST_run)
+  $(QUIET)$(call TEST_teardown)
+  $(QUIET)exit $$(cat $(OUT)$(TARGET_OR_MEMBER).status.test)
+endef
+
+define TEST_setup
+  @$(ECHO) -n "TEST		$(TARGET_OR_MEMBER) "
+  @$(ECHO) "[$(COLOR_YELLOW)SETUP$(COLOR_RESET)]"
+  $(QUIET)# Setup a target-specific results file
+  $(QUIET)(echo > $(OUT)$(TARGET_OR_MEMBER).setup.test)
+  $(QUIET)(echo 1 > $(OUT)$(TARGET_OR_MEMBER).status.test)
+  $(QUIET)(echo > $(OUT)$(TARGET_OR_MEMBER).cleanup.test)
+  $(QUIET)# No setup if we are not using QEMU
+  $(QUIET)# TODO(wad) this is racy until we use a vfs namespace
+  $(call if_qemu,\
+    $(QUIET)(echo "mkdir -p '$(SYSROOT)/proc' '$(SYSROOT)/dev' \
+                            '$(SYSROOT)/mnt/host/source'" \
+             >> "$(OUT)$(TARGET_OR_MEMBER).setup.test"))
+  $(call if_qemu,\
+    $(QUIET)(echo "$(MOUNT_CMD) --bind /mnt/host/source \
+             '$(SYSROOT)/mnt/host/source'" \
+             >> "$(OUT)$(TARGET_OR_MEMBER).setup.test"))
+  $(call if_qemu,\
+    $(QUIET)(echo "$(MOUNT_CMD) --bind /proc '$(SYSROOT)/proc'" \
+             >> "$(OUT)$(TARGET_OR_MEMBER).setup.test"))
+  $(call if_qemu,\
+    $(QUIET)(echo "$(MOUNT_CMD) --bind /dev '$(SYSROOT)/dev'" \
+             >> "$(OUT)$(TARGET_OR_MEMBER).setup.test"))
+endef
+
+define TEST_teardown
+  @$(ECHO) -n "TEST		$(TARGET_OR_MEMBER) "
+  @$(ECHO) "[$(COLOR_YELLOW)TEARDOWN$(COLOR_RESET)]"
+  $(call if_qemu, $(QUIET)$(SHELL) "$(OUT)$(TARGET_OR_MEMBER).cleanup.test")
+endef
+
+# Use GTEST_ARGS.[arch] if defined.
+override GTEST_ARGS.real = \
+ $(call if_qemu,$(GTEST_ARGS.qemu.$(QEMU_ARCH)),$(GTEST_ARGS.host.$(HOST_ARCH)))
+
+define TEST_run
+  @$(ECHO) -n "TEST		$(TARGET_OR_MEMBER) "
+  @$(ECHO) "[$(COLOR_GREEN)RUN$(COLOR_RESET)]"
+  $(QUIET)(echo 1 > "$(OUT)$(TARGET_OR_MEMBER).status.test")
+  $(QUIET)(echo $(ROOT_CMD) SRC="$(SRC)" $(QEMU_CMD) $(VALGRIND_CMD) \
+    "$(strip $(call if_qemu, $(SYSROOT_OUT),$(OUT))$(TARGET_OR_MEMBER))" \
+      $(if $(filter-out 0,$(words $(GTEST_ARGS.real))),$(GTEST_ARGS.real),\
+           $(GTEST_ARGS)) >> "$(OUT)$(TARGET_OR_MEMBER).setup.test")
+  -$(QUIET)$(call if_qemu,$(SUDO_CMD) $(UNSHARE_CMD) -m) $(SHELL) \
+      $(OUT)$(TARGET_OR_MEMBER).setup.test \
+  && echo 0 > "$(OUT)$(TARGET_OR_MEMBER).status.test"
+endef
+
+# Recursive list reversal so that we get RMDIR_ON_CLEAN in reverse order.
+define reverse
+$(if $(1),$(call reverse,$(wordlist 2,$(words $(1)),$(1)))) $(firstword $(1))
+endef
+
+clean: qemu_clean
+clean: CLEAN($(OUT)*.d) CLEAN($(OUT)*.o) CLEAN($(OUT)*.debug)
+clean: CLEAN($(OUT)*.test) CLEAN($(OUT)*.depends)
+clean: CLEAN($(OUT)*.gcno) CLEAN($(OUT)*.gcda) CLEAN($(OUT)*.gcov)
+clean: CLEAN($(OUT)lcov-coverage.info) CLEAN($(OUT)lcov-html)
+
+clean:
+	$(QUIET)# Always delete the containing directory last.
+	$(call silent_rmdir,$(OUT))
+
+FORCE: ;
+# Empty rule for use when no special targets are needed, like large_tests
+NONE:
+
+.PHONY: clean NONE valgrind NONE
+.DEFAULT_GOAL  :=  all
+# Don't let make blow away "intermediates"
+.PRECIOUS: %.pic.o %.pie.o %.a %.pic.a %.pie.a %.test
+
+# Start accruing build info
+OUT_DIRS = $(OUT)
+LD_DIRS = $(OUT)
+SRC_DIRS = $(SRC)
+
+include $(wildcard $(OUT)*.d)
+SUBMODULE_DIRS = $(wildcard $(SRC)/*/module.mk)
+include $(SUBMODULE_DIRS)
+
+
+else  ## In duplicate inclusions of common.mk
+
+# Get the current inclusion directory without a trailing slash
+MODULE := $(patsubst %/,%, \
+           $(dir $(lastword $(filter-out %common.mk,$(MAKEFILE_LIST)))))
+MODULE := $(subst $(SRC)/,,$(MODULE))
+MODULE_NAME := $(subst /,_,$(MODULE))
+#VPATH := $(MODULE):$(VPATH)
+
+
+# Depth first
+$(eval OUT_DIRS += $(OUT)$(MODULE))
+$(eval SRC_DIRS += $(OUT)$(MODULE))
+$(eval LD_DIRS := $(LD_DIRS):$(OUT)$(MODULE))
+
+# Add the defaults from this dir to rm_clean
+clean: CLEAN($(OUT)$(MODULE)/*.d) CLEAN($(OUT)$(MODULE)/*.o)
+clean: CLEAN($(OUT)$(MODULE)/*.debug) CLEAN($(OUT)$(MODULE)/*.test)
+clean: CLEAN($(OUT)$(MODULE)/*.depends)
+clean: CLEAN($(OUT)$(MODULE)/*.gcno) CLEAN($(OUT)$(MODULE)/*.gcda)
+clean: CLEAN($(OUT)$(MODULE)/*.gcov) CLEAN($(OUT)lcov-coverage.info)
+clean: CLEAN($(OUT)lcov-html)
+
+$(info + submodule: $(MODULE_NAME))
+# We must eval otherwise they may be dropped.
+MODULE_C_OBJECTS = $(patsubst $(SRC)/$(MODULE)/%.c,$(MODULE)/%.o,\
+  $(wildcard $(SRC)/$(MODULE)/*.c))
+$(eval $(MODULE_NAME)_C_OBJECTS ?= $(MODULE_C_OBJECTS))
+MODULE_CXX_OBJECTS = $(patsubst $(SRC)/$(MODULE)/%.cc,$(MODULE)/%.o,\
+  $(wildcard $(SRC)/$(MODULE)/*.cc))
+$(eval $(MODULE_NAME)_CXX_OBJECTS ?= $(MODULE_CXX_OBJECTS))
+
+# Note, $(MODULE) is implicit in the path to the %.c.
+# See $(C_OBJECTS) for more details.
+# Register rules for the module objects.
+$(eval $(call add_object_rules,$(MODULE_C_OBJECTS),CC,c,CFLAGS,$(SRC)/))
+$(eval $(call add_object_rules,$(MODULE_CXX_OBJECTS),CXX,cc,CXXFLAGS,$(SRC)/))
+
+# Continue recursive inclusion of module.mk files
+SUBMODULE_DIRS = $(wildcard $(SRC)/$(MODULE)/*/module.mk)
+include $(wildcard $(OUT)$(MODULE)/*.d)
+include $(SUBMODULE_DIRS)
+
+endif
+endif  ## pass-to-subcall wrapper for relocating the call directory
diff --git a/usb/common_types.h b/usb/common_types.h
new file mode 100644
index 0000000..2d84979
--- /dev/null
+++ b/usb/common_types.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2016 The Chromium OS Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef USB_COMMON_TYPES_H_
+#define USB_COMMON_TYPES_H_
+
+#include <string>
+#include <vector>
+
+namespace arc {
+
+struct DeviceInfo {
+  // ex: /dev/video0
+  std::string device_path;
+  // USB vender id
+  std::string usb_vid;
+  // USB product id
+  std::string usb_pid;
+  // Some cameras need to wait several frames to output correct images.
+  uint32_t frames_to_skip_after_streamon;
+
+  // Member definitions can be found in https://developer.android.com/
+  // reference/android/hardware/camera2/CameraCharacteristics.html
+  uint32_t lens_facing;
+  int32_t sensor_orientation;
+  float horizontal_view_angle_16_9;
+  float horizontal_view_angle_4_3;
+  std::vector<float> lens_info_available_focal_lengths;
+  float lens_info_minimum_focus_distance;
+  float lens_info_optimal_focus_distance;
+  float vertical_view_angle_16_9;
+  float vertical_view_angle_4_3;
+};
+
+typedef std::vector<DeviceInfo> DeviceInfos;
+
+struct SupportedFormat {
+  uint32_t width;
+  uint32_t height;
+  uint32_t fourcc;
+  // All the supported frame rates in fps with given width, height, and
+  // pixelformat. This is not sorted. For example, suppose width, height, and
+  // fourcc are 640x480 YUYV. If frameRates are 15.0 and 30.0, the camera
+  // supports outputting  640X480 YUYV in 15fps or 30fps.
+  std::vector<float> frameRates;
+};
+
+typedef std::vector<SupportedFormat> SupportedFormats;
+
+}  // namespace arc
+
+#endif  // USB_COMMON_TYPES_H_
diff --git a/usb/v4l2_camera_device.cc b/usb/v4l2_camera_device.cc
new file mode 100644
index 0000000..36e8ba7
--- /dev/null
+++ b/usb/v4l2_camera_device.cc
@@ -0,0 +1,514 @@
+/*
+ * Copyright 2016 The Chromium OS Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "usb/v4l2_camera_device.h"
+
+#include <fcntl.h>
+#include <linux/videodev2.h>
+#include <sys/ioctl.h>
+
+#include <limits>
+#include <utility>
+
+#include <base/files/file_enumerator.h>
+#include <base/files/file_util.h>
+#include <base/files/scoped_file.h>
+#include <base/strings/stringprintf.h>
+
+#include "usb/camera_characteristics.h"
+#include "usb/common.h"
+
+namespace arc {
+
+// USB VID and PID are both 4 bytes long.
+static const size_t kVidPidSize = 4;
+// /sys/class/video4linux/video{N}/device is a symlink to the corresponding
+// USB device info directory.
+static const char kVidPathTemplate[] =
+    "/sys/class/video4linux/%s/device/../idVendor";
+static const char kPidPathTemplate[] =
+    "/sys/class/video4linux/%s/device/../idProduct";
+
+// Allowed camera devices.
+static const char kAllowedCameraPrefix[] = "/dev/camera-internal";
+static const char kAllowedVideoPrefix[] = "/dev/video";
+
+static bool ReadIdFile(const std::string& path, std::string* id) {
+  char id_buf[kVidPidSize];
+  FILE* file = fopen(path.c_str(), "rb");
+  if (!file)
+    return false;
+  const bool success = fread(id_buf, kVidPidSize, 1, file) == 1;
+  fclose(file);
+  if (!success)
+    return false;
+  id->append(id_buf, kVidPidSize);
+  return true;
+}
+
+V4L2CameraDevice::V4L2CameraDevice() : stream_on_(false) {}
+
+V4L2CameraDevice::~V4L2CameraDevice() {
+  device_fd_.reset();
+}
+
+int V4L2CameraDevice::Connect(const std::string& device_path) {
+  VLOGF(1) << "Connecting device path: " << device_path;
+  if (device_path.compare(0, strlen(kAllowedVideoPrefix),
+                          kAllowedVideoPrefix)) {
+    LOGF(ERROR) << "Invalid device path " << device_path;
+    return -EINVAL;
+  }
+  if (device_fd_.is_valid()) {
+    LOGF(ERROR) << "A camera device is opened (" << device_fd_.get()
+                << "). Please close it first";
+    return -EIO;
+  }
+
+  device_fd_.reset(
+      TEMP_FAILURE_RETRY(open(device_path.c_str(), O_RDWR | O_NOFOLLOW)));
+  if (!device_fd_.is_valid()) {
+    LOGF(ERROR) << "Failed to open " << device_path << " : " << strerror(errno);
+    return -errno;
+  }
+
+  v4l2_capability cap = {};
+  if (TEMP_FAILURE_RETRY(ioctl(device_fd_.get(), VIDIOC_QUERYCAP, &cap)) != 0) {
+    LOGF(ERROR) << "VIDIOC_QUERYCAP fail: " << strerror(errno);
+    device_fd_.reset();
+    return -errno;
+  }
+
+  // TODO(henryhsu): Add MPLANE support.
+  if (!((cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) &&
+        !(cap.capabilities & V4L2_CAP_VIDEO_OUTPUT))) {
+    LOGF(ERROR) << "This is not a V4L2 video capture device";
+    device_fd_.reset();
+    return -EIO;
+  }
+
+  // Get and set format here is used to prevent multiple camera using.
+  // UVC driver will acquire lock in VIDIOC_S_FMT and VIDIOC_S_SMT will fail if
+  // the camera is being used by a user. The second user will fail in Connect()
+  // instead of StreamOn(). Usually apps show better error message if camera
+  // open fails. If start preview fails, some apps do not handle it well.
+  int ret;
+  v4l2_format fmt = {};
+  fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+  ret = TEMP_FAILURE_RETRY(ioctl(device_fd_.get(), VIDIOC_G_FMT, &fmt));
+  if (ret < 0) {
+    LOGF(ERROR) << "Unable to G_FMT: " << strerror(errno);
+    return -errno;
+  }
+  ret = TEMP_FAILURE_RETRY(ioctl(device_fd_.get(), VIDIOC_S_FMT, &fmt));
+  if (ret < 0) {
+    LOGF(WARNING) << "Unable to S_FMT: " << strerror(errno)
+                  << ", maybe camera is being used by another app.";
+    return -errno;
+  }
+  return 0;
+}
+
+void V4L2CameraDevice::Disconnect() {
+  stream_on_ = false;
+  device_fd_.reset();
+  buffers_at_client_.clear();
+}
+
+int V4L2CameraDevice::StreamOn(uint32_t width,
+                               uint32_t height,
+                               uint32_t pixel_format,
+                               float frame_rate,
+                               std::vector<int>* fds,
+                               uint32_t* buffer_size) {
+  if (!device_fd_.is_valid()) {
+    LOGF(ERROR) << "Device is not opened";
+    return -ENODEV;
+  }
+  if (stream_on_) {
+    LOGF(ERROR) << "Device has stream already started";
+    return -EIO;
+  }
+
+  // Some drivers use rational time per frame instead of float frame rate, this
+  // constant k is used to convert between both: A fps -> [k/k*A] seconds/frame.
+  const int kFrameRatePrecision = 10000;
+  int ret;
+  v4l2_format fmt = {};
+  fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+  fmt.fmt.pix.width = width;
+  fmt.fmt.pix.height = height;
+  fmt.fmt.pix.pixelformat = pixel_format;
+  ret = TEMP_FAILURE_RETRY(ioctl(device_fd_.get(), VIDIOC_S_FMT, &fmt));
+  if (ret < 0) {
+    LOGF(ERROR) << "Unable to S_FMT: " << strerror(errno);
+    return -errno;
+  }
+  VLOGF(1) << "Actual width: " << fmt.fmt.pix.width
+           << ", height: " << fmt.fmt.pix.height
+           << ", pixelformat: " << std::hex << fmt.fmt.pix.pixelformat;
+
+  if (width != fmt.fmt.pix.width || height != fmt.fmt.pix.height ||
+      pixel_format != fmt.fmt.pix.pixelformat) {
+    LOGF(ERROR) << "Unsupported format: width " << width << ", height "
+                << height << ", pixelformat " << pixel_format;
+    return -EINVAL;
+  }
+
+  // Set capture framerate in the form of capture interval.
+  v4l2_streamparm streamparm = {};
+  streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+  // The following line checks that the driver knows about framerate get/set.
+  if (TEMP_FAILURE_RETRY(ioctl(device_fd_.get(), VIDIOC_G_PARM, &streamparm)) >=
+      0) {
+    // Now check if the device is able to accept a capture framerate set.
+    if (streamparm.parm.capture.capability & V4L2_CAP_TIMEPERFRAME) {
+      // |frame_rate| is float, approximate by a fraction.
+      streamparm.parm.capture.timeperframe.numerator = kFrameRatePrecision;
+      streamparm.parm.capture.timeperframe.denominator =
+          (frame_rate * kFrameRatePrecision);
+
+      if (TEMP_FAILURE_RETRY(
+              ioctl(device_fd_.get(), VIDIOC_S_PARM, &streamparm)) < 0) {
+        LOGF(ERROR) << "Failed to set camera framerate";
+        return -EIO;
+      }
+      VLOGF(1) << "Actual camera driver framerate: "
+               << streamparm.parm.capture.timeperframe.denominator << "/"
+               << streamparm.parm.capture.timeperframe.numerator;
+    }
+  }
+  float fps = streamparm.parm.capture.timeperframe.denominator /
+              streamparm.parm.capture.timeperframe.numerator;
+  if (std::fabs(fps - frame_rate) > std::numeric_limits<float>::epsilon()) {
+    LOGF(ERROR) << "Unsupported frame rate " << frame_rate;
+    return -EINVAL;
+  }
+  *buffer_size = fmt.fmt.pix.sizeimage;
+  VLOGF(1) << "Buffer size: " << *buffer_size;
+
+  v4l2_requestbuffers req_buffers;
+  memset(&req_buffers, 0, sizeof(req_buffers));
+  req_buffers.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+  req_buffers.memory = V4L2_MEMORY_MMAP;
+  req_buffers.count = kNumVideoBuffers;
+  if (TEMP_FAILURE_RETRY(
+          ioctl(device_fd_.get(), VIDIOC_REQBUFS, &req_buffers)) < 0) {
+    LOGF(ERROR) << "REQBUFS fails: " << strerror(errno);
+    return -errno;
+  }
+  VLOGF(1) << "Requested buffer number: " << req_buffers.count;
+
+  buffers_at_client_.resize(req_buffers.count);
+  std::vector<base::ScopedFD> temp_fds;
+  for (uint32_t i = 0; i < req_buffers.count; i++) {
+    v4l2_exportbuffer expbuf;
+    memset(&expbuf, 0, sizeof(expbuf));
+    expbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    expbuf.index = i;
+    if (TEMP_FAILURE_RETRY(ioctl(device_fd_.get(), VIDIOC_EXPBUF, &expbuf)) <
+        0) {
+      LOGF(ERROR) << "EXPBUF (" << i << ") fails: " << strerror(errno);
+      return -errno;
+    }
+    VLOG(1) << "Exported frame buffer fd: " << expbuf.fd;
+    temp_fds.push_back(base::ScopedFD(expbuf.fd));
+    buffers_at_client_[i] = false;
+
+    v4l2_buffer buffer = {};
+    buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    buffer.index = i;
+    buffer.memory = V4L2_MEMORY_MMAP;
+
+    if (TEMP_FAILURE_RETRY(ioctl(device_fd_.get(), VIDIOC_QBUF, &buffer)) < 0) {
+      LOGF(ERROR) << "QBUF (" << i << ") fails: " << strerror(errno);
+      return -errno;
+    }
+  }
+
+  v4l2_buf_type capture_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+  if (TEMP_FAILURE_RETRY(
+          ioctl(device_fd_.get(), VIDIOC_STREAMON, &capture_type)) < 0) {
+    LOGF(ERROR) << "STREAMON fails: " << strerror(errno);
+    return -errno;
+  }
+
+  for (size_t i = 1; i < temp_fds.size(); i++) {
+    fds->push_back(temp_fds[i].release());
+  }
+
+  stream_on_ = true;
+  return 0;
+}
+
+int V4L2CameraDevice::StreamOff() {
+  if (!device_fd_.is_valid()) {
+    LOGF(ERROR) << "Device is not opened";
+    return -ENODEV;
+  }
+  // Because UVC driver cannot allow STREAMOFF after REQBUF(0), adding a check
+  // here to prevent it.
+  if (!stream_on_) {
+    return 0;
+  }
+
+  v4l2_buf_type capture_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+  if (TEMP_FAILURE_RETRY(
+          ioctl(device_fd_.get(), VIDIOC_STREAMOFF, &capture_type)) < 0) {
+    LOGF(ERROR) << "STREAMOFF fails: " << strerror(errno);
+    return -errno;
+  }
+  v4l2_requestbuffers req_buffers;
+  memset(&req_buffers, 0, sizeof(req_buffers));
+  req_buffers.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+  req_buffers.memory = V4L2_MEMORY_MMAP;
+  req_buffers.count = 0;
+  if (TEMP_FAILURE_RETRY(
+          ioctl(device_fd_.get(), VIDIOC_REQBUFS, &req_buffers)) < 0) {
+    LOGF(ERROR) << "REQBUFS fails: " << strerror(errno);
+    return -errno;
+  }
+  buffers_at_client_.clear();
+  stream_on_ = false;
+  return 0;
+}
+
+int V4L2CameraDevice::GetNextFrameBuffer(uint32_t* buffer_id,
+                                         uint32_t* data_size) {
+  if (!device_fd_.is_valid()) {
+    LOGF(ERROR) << "Device is not opened";
+    return -ENODEV;
+  }
+  if (!stream_on_) {
+    LOGF(ERROR) << "Streaming is not started";
+    return -EIO;
+  }
+
+  v4l2_buffer buffer;
+  memset(&buffer, 0, sizeof(buffer));
+  buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+  buffer.memory = V4L2_MEMORY_MMAP;
+  if (TEMP_FAILURE_RETRY(ioctl(device_fd_.get(), VIDIOC_DQBUF, &buffer)) < 0) {
+    LOGF(ERROR) << "DQBUF fails: " << strerror(errno);
+    return -errno;
+  }
+  VLOGF(1) << "DQBUF returns index " << buffer.index << " length "
+           << buffer.length;
+
+  if (buffer.index >= buffers_at_client_.size() ||
+      buffers_at_client_[buffer.index]) {
+    LOGF(ERROR) << "Invalid buffer id " << buffer.index;
+    return -EINVAL;
+  }
+  *buffer_id = buffer.index;
+  *data_size = buffer.bytesused;
+  buffers_at_client_[buffer.index] = true;
+  return 0;
+}
+
+int V4L2CameraDevice::ReuseFrameBuffer(uint32_t buffer_id) {
+  if (!device_fd_.is_valid()) {
+    LOGF(ERROR) << "Device is not opened";
+    return -ENODEV;
+  }
+  if (!stream_on_) {
+    LOGF(ERROR) << "Streaming is not started";
+    return -EIO;
+  }
+
+  VLOG(1) << "Reuse buffer id: " << buffer_id;
+  if (buffer_id >= buffers_at_client_.size() ||
+      !buffers_at_client_[buffer_id]) {
+    LOGF(ERROR) << "Invalid buffer id: " << buffer_id;
+    return -EINVAL;
+  }
+  v4l2_buffer buffer;
+  memset(&buffer, 0, sizeof(buffer));
+  buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+  buffer.memory = V4L2_MEMORY_MMAP;
+  buffer.index = buffer_id;
+  if (TEMP_FAILURE_RETRY(ioctl(device_fd_.get(), VIDIOC_QBUF, &buffer)) < 0) {
+    LOGF(ERROR) << "QBUF fails: " << strerror(errno);
+    return -errno;
+  }
+  buffers_at_client_[buffer.index] = false;
+  return 0;
+}
+
+const SupportedFormats V4L2CameraDevice::GetDeviceSupportedFormats(
+    const std::string& device_path) {
+  VLOG(1) << "Query supported formats for " << device_path;
+  SupportedFormats formats;
+  if (device_path.compare(0, strlen(kAllowedVideoPrefix),
+                          kAllowedVideoPrefix)) {
+    LOGF(ERROR) << "Invalid device path " << device_path;
+    return formats;
+  }
+  base::ScopedFD fd(
+      TEMP_FAILURE_RETRY(open(device_path.c_str(), O_RDONLY | O_NOFOLLOW)));
+  if (!fd.is_valid()) {
+    LOGF(ERROR) << "Failed to open " << device_path << " : " << strerror(errno);
+    return formats;
+  }
+
+  v4l2_fmtdesc v4l2_format = {};
+  v4l2_format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+  for (;
+       TEMP_FAILURE_RETRY(ioctl(fd.get(), VIDIOC_ENUM_FMT, &v4l2_format)) == 0;
+       ++v4l2_format.index) {
+    SupportedFormat supported_format;
+    supported_format.fourcc = v4l2_format.pixelformat;
+
+    v4l2_frmsizeenum frame_size = {};
+    frame_size.pixel_format = v4l2_format.pixelformat;
+    for (; HANDLE_EINTR(ioctl(fd.get(), VIDIOC_ENUM_FRAMESIZES, &frame_size)) ==
+           0;
+         ++frame_size.index) {
+      if (frame_size.type == V4L2_FRMSIZE_TYPE_DISCRETE) {
+        supported_format.width = frame_size.discrete.width;
+        supported_format.height = frame_size.discrete.height;
+      } else if (frame_size.type == V4L2_FRMSIZE_TYPE_STEPWISE ||
+                 frame_size.type == V4L2_FRMSIZE_TYPE_CONTINUOUS) {
+        // TODO(henryhsu): see http://crbug.com/249953, support these devices.
+        LOGF(ERROR) << "Stepwise and continuous frame size are unsupported";
+        return formats;
+      }
+
+      supported_format.frameRates = GetFrameRateList(
+          fd.get(), v4l2_format.pixelformat, frame_size.discrete.width,
+          frame_size.discrete.height);
+      formats.push_back(supported_format);
+    }
+  }
+  return formats;
+}
+
+const DeviceInfos V4L2CameraDevice::GetCameraDeviceInfos() {
+  // Only internal camera is allowed to be used in container.
+  // /dev/camera-internal* symbolic links should have been created and pointed
+  // to the internal cameras according to Vid and Pid.
+  std::unordered_map<std::string, std::string> devices =
+      GetCameraDevicesByPattern(std::string(kAllowedCameraPrefix) + "*");
+
+  if (devices.empty()) {
+    // Symbolic link /dev/camera-internal* is generated from the udev rules
+    // 50-camera.rules in chromeos-bsp-{BOARD}-private. The rules file may not
+    // exist, and it will cause this error. (b/29425883)
+    LOGF(ERROR) << "Cannot find any camera devices with "
+                << kAllowedCameraPrefix << "*";
+    devices = GetCameraDevicesByPattern(std::string(kAllowedVideoPrefix) + "*");
+    LOGF(ERROR) << "List available cameras as follows: ";
+    for (const auto& device : devices) {
+      size_t pos = device.first.find(":");
+      if (pos != std::string::npos) {
+        LOGF(ERROR) << "Device path: " << device.second
+                    << " vid: " << device.first.substr(0, pos - 1)
+                    << " pid: " << device.first.substr(pos + 1);
+      } else {
+        LOGF(ERROR) << "Invalid device: " << device.first;
+      }
+    }
+    return DeviceInfos();
+  }
+
+  CameraCharacteristics characteristics;
+  return characteristics.GetCharacteristicsFromFile(devices);
+}
+
+std::vector<float> V4L2CameraDevice::GetFrameRateList(int fd,
+                                                      uint32_t fourcc,
+                                                      uint32_t width,
+                                                      uint32_t height) {
+  std::vector<float> frame_rates;
+
+  v4l2_frmivalenum frame_interval = {};
+  frame_interval.pixel_format = fourcc;
+  frame_interval.width = width;
+  frame_interval.height = height;
+  for (; TEMP_FAILURE_RETRY(
+             ioctl(fd, VIDIOC_ENUM_FRAMEINTERVALS, &frame_interval)) == 0;
+       ++frame_interval.index) {
+    if (frame_interval.type == V4L2_FRMIVAL_TYPE_DISCRETE) {
+      if (frame_interval.discrete.numerator != 0) {
+        frame_rates.push_back(
+            frame_interval.discrete.denominator /
+            static_cast<float>(frame_interval.discrete.numerator));
+      }
+    } else if (frame_interval.type == V4L2_FRMIVAL_TYPE_CONTINUOUS ||
+               frame_interval.type == V4L2_FRMIVAL_TYPE_STEPWISE) {
+      // TODO(henryhsu): see http://crbug.com/249953, support these devices.
+      LOGF(ERROR) << "Stepwise and continuous frame interval are unsupported";
+      return frame_rates;
+    }
+  }
+  // Some devices, e.g. Kinect, do not enumerate any frame rates, see
+  // http://crbug.com/412284. Set their frame_rate to zero.
+  if (frame_rates.empty()) {
+    frame_rates.push_back(0);
+  }
+  return frame_rates;
+}
+
+const std::unordered_map<std::string, std::string>
+V4L2CameraDevice::GetCameraDevicesByPattern(std::string pattern) {
+  const base::FilePath path(pattern);
+  base::FileEnumerator enumerator(path.DirName(), false,
+                                  base::FileEnumerator::FILES,
+                                  path.BaseName().value());
+  std::unordered_map<std::string, std::string> devices;
+  std::string device_path, device_name;
+
+  while (!enumerator.Next().empty()) {
+    const base::FileEnumerator::FileInfo info = enumerator.GetInfo();
+    const std::string name = info.GetName().value();
+    const base::FilePath target_path = path.DirName().Append(name);
+
+    base::FilePath target;
+    if (base::ReadSymbolicLink(target_path, &target)) {
+      device_path = "/dev/" + target.value();
+      device_name = target.value();
+    } else {
+      device_path = target_path.value();
+      device_name = name;
+    }
+
+    const base::ScopedFD fd(
+        TEMP_FAILURE_RETRY(open(device_path.c_str(), O_RDONLY | O_NOFOLLOW)));
+    if (!fd.is_valid()) {
+      VLOGF(1) << "Couldn't open " << device_name;
+      continue;
+    }
+
+    v4l2_capability cap;
+    if ((TEMP_FAILURE_RETRY(ioctl(fd.get(), VIDIOC_QUERYCAP, &cap)) == 0) &&
+        ((cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) &&
+         !(cap.capabilities & V4L2_CAP_VIDEO_OUTPUT))) {
+      const std::string vidPath =
+          base::StringPrintf(kVidPathTemplate, device_name.c_str());
+      const std::string pidPath =
+          base::StringPrintf(kPidPathTemplate, device_name.c_str());
+
+      std::string usb_vid, usb_pid;
+      if (!ReadIdFile(vidPath, &usb_vid)) {
+        VLOGF(1) << "Couldn't read VID of " << device_name;
+        continue;
+      }
+      if (!ReadIdFile(pidPath, &usb_pid)) {
+        VLOGF(1) << "Couldn't read PID of " << device_name;
+        continue;
+      }
+      VLOGF(1) << "Device path: " << device_path << " vid: " << usb_vid
+               << " pid: " << usb_pid;
+      devices.insert(std::make_pair(usb_vid + ":" + usb_pid, device_path));
+    }
+  }
+  if (devices.empty()) {
+    LOGF(ERROR) << "Cannot find any camera devices with pattern " << pattern;
+  }
+  return devices;
+}
+
+}  // namespace arc
diff --git a/usb/v4l2_camera_device.h b/usb/v4l2_camera_device.h
new file mode 100644
index 0000000..eff225a
--- /dev/null
+++ b/usb/v4l2_camera_device.h
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2016 The Chromium OS Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef USB_V4L2_CAMERA_DEVICE_H_
+#define USB_V4L2_CAMERA_DEVICE_H_
+
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include <base/files/scoped_file.h>
+
+#include "usb/common_types.h"
+
+namespace arc {
+
+class V4L2CameraDevice {
+ public:
+  V4L2CameraDevice();
+  virtual ~V4L2CameraDevice();
+
+  // Connect camera device with |device_path|. Return 0 if device is opened
+  // successfully. Otherwise, return -|errno|.
+  int Connect(const std::string& device_path);
+
+  // Disconnect camera device. This function is a no-op if the camera device
+  // is not connected. If the stream is on, this function will also stop the
+  // stream.
+  void Disconnect();
+
+  // Enable camera device stream. Setup captured frame with |width|x|height|
+  // resolution, |pixel_format|, and |frame_rate|. Get frame buffer file
+  // descriptors |fds| and |buffer_size|. |buffer_size| is the size allocated
+  // for each buffer. The ownership of |fds| are transferred to the caller and
+  // |fds| should be closed when done. Caller can memory map |fds| and should
+  // unmap when done. Return 0 if device supports the format. Otherwise, return
+  // -|errno|. This function should be called after Connect().
+  int StreamOn(uint32_t width,
+               uint32_t height,
+               uint32_t pixel_format,
+               float frame_rate,
+               std::vector<int>* fds,
+               uint32_t* buffer_size);
+
+  // Disable camera device stream. Return 0 if device disables stream
+  // successfully. Otherwise, return -|errno|. This function is a no-op if the
+  // stream is already stopped.
+  int StreamOff();
+
+  // Get next frame buffer from device. Device returns the corresponding
+  // buffer with |buffer_id| and |data_size| bytes. |data_size| is how many
+  // bytes used in the buffer for this frame. Return 0 if device gets the
+  // buffer successfully. Otherwise, return -|errno|. Return -EAGAIN immediately
+  // if next frame buffer is not ready. This function should be called after
+  // StreamOn().
+  int GetNextFrameBuffer(uint32_t* buffer_id, uint32_t* data_size);
+
+  // Return |buffer_id| buffer to device. Return 0 if the buffer is returned
+  // successfully. Otherwise, return -|errno|. This function should be called
+  // after StreamOn().
+  int ReuseFrameBuffer(uint32_t buffer_id);
+
+  // Get all supported formats of device by |device_path|. This function can be
+  // called without calling Connect().
+  const SupportedFormats GetDeviceSupportedFormats(
+      const std::string& device_path);
+
+  // Get all camera devices information. This function can be called without
+  // calling Connect().
+  const DeviceInfos GetCameraDeviceInfos();
+
+ private:
+  std::vector<float> GetFrameRateList(int fd,
+                                      uint32_t fourcc,
+                                      uint32_t width,
+                                      uint32_t height);
+  const std::unordered_map<std::string, std::string> GetCameraDevicesByPattern(
+      std::string pattern);
+
+  // The number of video buffers we want to request in kernel.
+  const int kNumVideoBuffers = 4;
+
+  // The opened device fd.
+  base::ScopedFD device_fd_;
+
+  // StreamOn state
+  bool stream_on_;
+
+  // True if the buffer is used by client after GetNextFrameBuffer().
+  std::vector<bool> buffers_at_client_;
+
+  DISALLOW_COPY_AND_ASSIGN(V4L2CameraDevice);
+};
+
+}  // namespace arc
+
+#endif  // USB_V4L2_CAMERA_DEVICE_H_