diff --git a/server/cros/faftsequence.py b/server/cros/faftsequence.py
index cf3ec05..da65529 100644
--- a/server/cros/faftsequence.py
+++ b/server/cros/faftsequence.py
@@ -106,7 +106,7 @@
           error.TestError: if USB disk not detected or not a test image.
         """
         self.servo.set('usb_mux_sel1', 'servo_sees_usbkey')
-        usb_dev = self.probe_host_usb_dev()
+        usb_dev = self.servo.probe_host_usb_dev()
         if not usb_dev:
             raise error.TestError(
                     'An USB disk should be plugged in the servo board.')
diff --git a/server/cros/servo.py b/server/cros/servo.py
index 1b6d2a6..9919e5b 100644
--- a/server/cros/servo.py
+++ b/server/cros/servo.py
@@ -5,10 +5,9 @@
 # Expects to be run in an environment with sudo and no interactive password
 # prompt, such as within the Chromium OS development chroot.
 
-import logging
-import time
-import xmlrpclib
-import subprocess
+import logging, os, subprocess, time, xmlrpclib
+from autotest_lib.client.bin import utils as client_utils
+from autotest_lib.server import utils
 
 class Servo:
     """Manages control of a Servo board.
@@ -34,12 +33,16 @@
     # Delays to deal with computer transitions.
     SLEEP_DELAY = 6
     BOOT_DELAY = 10
-    RECOVERY_INSTALL_DELAY = 300
+    RECOVERY_BOOT_DELAY = 30
+    RECOVERY_INSTALL_DELAY = 180
 
     # Servo-specific delays.
     MAX_SERVO_STARTUP_DELAY = 10
     SERVO_SEND_SIGNAL_DELAY = 0.5
 
+    # Time between an usb disk plugged-in and detected in the system.
+    USB_DETECTION_DELAY = 10
+
     def __init__(self, servo_host=None, servo_port=None,
                  xml_config=['servo.xml'], servo_vid=None, servo_pid=None,
                  servo_serial=None, cold_reset=False):
@@ -283,6 +286,111 @@
         self._server.set(gpio_name, gpio_value)
 
 
+    # TODO(waihong) It may fail if multiple servo's are connected to the same
+    # host. Should look for a better way, like the USB serial name, to identify
+    # the USB device.
+    def probe_host_usb_dev(self):
+        """Probe the USB disk device plugged-in the servo from the host side.
+
+        It tries to switch the USB mux to make the host unable to see the
+        USB disk and compares the result difference.
+
+        This only works if the servo is attached to the local host.
+
+        Returns:
+          A string of USB disk path, like '/dev/sdb', or None if not existed.
+        """
+        cmd = 'ls /dev/sd[a-z]'
+        original_value = self.get('usb_mux_sel1')
+
+        # Make the host unable to see the USB disk.
+        if original_value != 'dut_sees_usbkey':
+            self.set('usb_mux_sel1', 'dut_sees_usbkey')
+            time.sleep(self.USB_DETECTION_DELAY)
+        no_usb_set = set(utils.system_output(cmd, ignore_status=True).split())
+
+        # Make the host able to see the USB disk.
+        self.set('usb_mux_sel1', 'servo_sees_usbkey')
+        time.sleep(self.USB_DETECTION_DELAY)
+        has_usb_set = set(utils.system_output(cmd, ignore_status=True).split())
+
+        # Back to its original value.
+        if original_value != 'servo_sees_usbkey':
+            self.set('usb_mux_sel1', original_value)
+            time.sleep(self.USB_DETECTION_DELAY)
+
+        diff_set = has_usb_set - no_usb_set
+        if len(diff_set) == 1:
+            return diff_set.pop()
+        else:
+            return None
+
+
+    def install_recovery_image(self, image_path=None, usb_mount_point=None,
+                               wait_for_completion=True):
+        """Install the recovery image specied by the path onto the DUT.
+
+        This method uses google recovery mode to install a recovery image
+        onto a DUT through the use of a USB stick that is mounted on a servo
+        board specified by the usb_mount_point.  If no image path is specified
+        we use the recovery image already on the usb image.
+
+        Args:
+            image_path: Path on the host to the recovery image.
+            usb_mount_point:  When servo_sees_usbkey is enabled, which dev
+                              e.g. /dev/sdb will the usb key show up as.
+            wait_for_completion: Whether to wait for completion of the
+                                 factory install and disable the USB hub
+                                 before returning.  Currently this is just
+                                 a hardcoded wait of RECOVERY_INSTALL_DELAY
+                                 (for the recovery process to complete).
+        """
+        # Set up Servo's usb mux.
+        self.set('prtctl4_pwren', 'on')
+        self.enable_usb_hub(host=True)
+        if image_path and usb_mount_point:
+          logging.info('Installing recovery image onto usb stick.  '
+                       'This takes a while ...')
+          client_utils.poll_for_condition(
+              lambda: os.path.exists(usb_mount_point),
+              timeout=Servo.USB_DETECTION_DELAY,
+              desc="%s exists" % usb_mount_point)
+          utils.system(' '.join(
+                           ['sudo', 'dd', 'if=%s' % image_path,
+                            'of=%s' % usb_mount_point, 'bs=4M']))
+
+        # Turn the device off.
+        self.power_normal_press()
+        time.sleep(Servo.SLEEP_DELAY)
+
+        # Boot in recovery mode.
+        try:
+            self.set('usb_mux_sel1', 'dut_sees_usbkey')
+            self.enable_recovery_mode()
+            self.power_normal_press()
+            time.sleep(Servo.RECOVERY_BOOT_DELAY)
+            self.disable_recovery_mode()
+
+            if wait_for_completion:
+                # Enable recovery installation.
+                logging.info('Running the recovery process on the DUT. '
+                             'Waiting %d seconds for recovery to complete ...',
+                             Servo.RECOVERY_INSTALL_DELAY)
+                time.sleep(Servo.RECOVERY_INSTALL_DELAY)
+
+                # Go back into normal mode and reboot.
+                # Machine automatically reboots after the usb key is removed.
+                logging.info('Removing the usb key from the DUT.')
+                self.disable_usb_hub()
+                time.sleep(Servo.BOOT_DELAY)
+        except:
+            # In case anything went wrong we want to make sure to do a clean
+            # reset.
+            self.disable_recovery_mode()
+            self.warm_reset()
+            raise
+
+
     def _init_seq_cold_reset_devmode(self):
         """Cold reset, init device, and boot in dev-mode."""
         self.cold_reset()
diff --git a/server/cros/servo_test.py b/server/cros/servo_test.py
index a47f749..fc33f3a 100644
--- a/server/cros/servo_test.py
+++ b/server/cros/servo_test.py
@@ -9,7 +9,6 @@
 import time
 import xmlrpclib
 
-from autotest_lib.client.bin import utils
 from autotest_lib.client.common_lib import error
 from autotest_lib.server import autotest, site_host_attributes, test, utils
 from autotest_lib.server.cros import servo
@@ -72,9 +71,6 @@
         },
     }
 
-    # Time between an usb disk plugged-in and detected in the system.
-    USB_DETECTION_DELAY = 10
-
     def initialize(self, host, cmdline_args, use_pyauto=False, use_faft=False):
         """Create a Servo object and install the dependency.
 
@@ -131,95 +127,6 @@
                 self._autotest_client.run_test(info['client_test'])
                 self.launch_client(info)
 
-    # TODO(waihong) It may fail if multiple servo's are connected to the same
-    # host. Should look for a better way, like the USB serial name, to identify
-    # the USB device.
-    def probe_host_usb_dev(self):
-        """Probe the USB disk device plugged-in the servo from the host side.
-
-        It tries to switch the USB mux to make the host unable to see the
-        USB disk and compares the result difference.
-
-        Returns:
-          A string of USB disk path, like '/dev/sdb', or None if not existed.
-        """
-        cmd = 'ls /dev/sd[a-z]'
-        original_value = self.servo.get('usb_mux_sel1')
-
-        # Make the host unable to see the USB disk.
-        if original_value != 'dut_sees_usbkey':
-            self.servo.set('usb_mux_sel1', 'dut_sees_usbkey')
-            time.sleep(self.USB_DETECTION_DELAY)
-        no_usb_set = set(utils.system_output(cmd, ignore_status=True).split())
-
-        # Make the host able to see the USB disk.
-        self.servo.set('usb_mux_sel1', 'servo_sees_usbkey')
-        time.sleep(self.USB_DETECTION_DELAY)
-        has_usb_set = set(utils.system_output(cmd, ignore_status=True).split())
-
-        # Back to its original value.
-        if original_value != 'servo_sees_usbkey':
-            self.servo.set('usb_mux_sel1', original_value)
-            time.sleep(self.USB_DETECTION_DELAY)
-
-        diff_set = has_usb_set - no_usb_set
-        if len(diff_set) == 1:
-            return diff_set.pop()
-        else:
-            return None
-
-    def install_recovery_image(self, image_path=None, usb_mount_point=None):
-        """Install the recovery image specied by the path onto the DUT.
-
-        This method uses google recovery mode to install a recovery image
-        onto a DUT through the use of a USB stick that is mounted on a servo
-        board specified by the usb_mount_point.  If no image path is specified
-        we use the recovery image already on the usb image.
-
-        Args:
-            image_path: Path on the host to the recovery image.
-            usb_mount_point:  When servo_sees_usbkey is enabled, which dev
-                              e.g. /dev/sdb will the usb key show up as.
-        """
-        # Set up Servo's usb mux.
-        self.servo.set('prtctl4_pwren', 'on')
-        self.servo.enable_usb_hub(host=True)
-        if image_path and usb_mount_point:
-          logging.info('Installing recovery image onto usb stick.  '
-                       'This takes a while ...')
-          utils.system(' '.join(
-                           ['sudo', 'dd', 'if=%s' % image_path,
-                            'of=%s' % usb_mount_point, 'bs=4M']))
-
-        # Turn the device off.
-        self.servo.power_normal_press()
-        time.sleep(servo.Servo.SLEEP_DELAY)
-
-        # Boot in recovery mode.
-        try:
-            self.servo.enable_recovery_mode()
-            self.servo.power_normal_press()
-            time.sleep(servo.Servo.BOOT_DELAY)
-
-            # Enable recovery installation.
-            self.servo.set('usb_mux_sel1', 'dut_sees_usbkey')
-            logging.info('Running the recovery process on the DUT. '
-                         'Waiting %d seconds for recovery to complete ...',
-                         servo.Servo.RECOVERY_INSTALL_DELAY)
-            time.sleep(servo.Servo.RECOVERY_INSTALL_DELAY)
-
-            # Go back into normal mode and reboot.
-            # Machine automatically reboots after the usb key is removed.
-            self.servo.disable_recovery_mode()
-            logging.info('Removing the usb key from the DUT.')
-            self.servo.disable_usb_hub()
-            time.sleep(servo.Servo.BOOT_DELAY)
-        except:
-            # In case anything went wrong we want to make sure to do a clean
-            # reset.
-            self.servo.disable_recovery_mode()
-            self.servo.warm_reset()
-            raise
 
     def assert_ping(self):
         """Ping to assert that the device is up."""
diff --git a/server/site_tests/platform_InstallRecoveryImage/platform_InstallRecoveryImage.py b/server/site_tests/platform_InstallRecoveryImage/platform_InstallRecoveryImage.py
index e149614..7772a0f 100755
--- a/server/site_tests/platform_InstallRecoveryImage/platform_InstallRecoveryImage.py
+++ b/server/site_tests/platform_InstallRecoveryImage/platform_InstallRecoveryImage.py
@@ -9,7 +9,7 @@
     version = 1
 
     def run_once(self, host, image, usb):
-        self.install_recovery_image(image, usb)
+        self.servo.install_recovery_image(image, usb)
         # Verify we can ping the machine afterwards.
         # TODO(sosa): Add a better test of valid image recovery.
         self.assert_ping()