blob: 02749b31da4e272a5ff8ebbdcb27e1a08851add6 [file] [log] [blame]
Simran Basia9f41032012-05-11 14:21:58 -07001# Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
Todd Broche505b8d2011-03-21 18:19:54 -07002# Use of this source code is governed by a BSD-style license that can be
3# found in the LICENSE file.
4"""Servo Server."""
Simran Basia9f41032012-05-11 14:21:58 -07005import fnmatch
Todd Broche505b8d2011-03-21 18:19:54 -07006import imp
7import logging
Simran Basia9f41032012-05-11 14:21:58 -07008import os
9import shutil
Todd Broche505b8d2011-03-21 18:19:54 -070010import SimpleXMLRPCServer
Simran Basia9f41032012-05-11 14:21:58 -070011import subprocess
12import tempfile
Todd Broch7a91c252012-02-03 12:37:45 -080013import time
Simran Basia9f41032012-05-11 14:21:58 -070014import urllib
Todd Broche505b8d2011-03-21 18:19:54 -070015
16# TODO(tbroch) deprecate use of relative imports
Vic Yangbe6cf262012-09-10 10:40:56 +080017from drv.hw_driver import HwDriverError
Aaron.Chuang88eff332014-07-31 08:32:00 +080018import bbadc
Simran Basia9ad25e2013-04-23 11:57:00 -070019import bbi2c
Simran Basi5492bde2013-05-16 17:08:47 -070020import bbgpio
Simran Basi949309b2013-05-31 15:12:15 -070021import bbuart
Todd Broche505b8d2011-03-21 18:19:54 -070022import ftdigpio
23import ftdii2c
Todd Brochdbb09982011-10-02 07:14:26 -070024import ftdi_common
Todd Broch47c43f42011-05-26 15:11:31 -070025import ftdiuart
Rong Changc6c8c022014-08-11 14:07:11 +080026import i2cbus
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -080027import keyboard_handlers
Simran Basie750a342013-03-12 13:45:26 -070028import servo_interfaces
Todd Broche505b8d2011-03-21 18:19:54 -070029
30MAX_I2C_CLOCK_HZ = 100000
31
Todd Brochdbb09982011-10-02 07:14:26 -070032
Todd Broche505b8d2011-03-21 18:19:54 -070033class ServodError(Exception):
34 """Exception class for servod."""
35
36class Servod(object):
37 """Main class for Servo debug/controller Daemon."""
Simran Basia9f41032012-05-11 14:21:58 -070038 _USB_DETECTION_DELAY = 10
Fang Deng90377712013-06-03 15:51:48 -070039 _USB_POWEROFF_DELAY = 2
Simran Basia9f41032012-05-11 14:21:58 -070040 _HTTP_PREFIX = "http://"
Fang Deng90377712013-06-03 15:51:48 -070041 _USB_J3 = "usb_mux_sel1"
42 _USB_J3_TO_SERVO = "servo_sees_usbkey"
43 _USB_J3_TO_DUT = "dut_sees_usbkey"
44 _USB_J3_PWR = "prtctl4_pwren"
45 _USB_J3_PWR_ON = "on"
46 _USB_J3_PWR_OFF = "off"
Simran Basia9f41032012-05-11 14:21:58 -070047
J. Richard Barnettee2820552013-03-14 16:13:46 -070048 def __init__(self, config, vendor, product, serialname=None,
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -080049 interfaces=None, board="", version=None, usbkm232=None):
Todd Broche505b8d2011-03-21 18:19:54 -070050 """Servod constructor.
51
52 Args:
53 config: instance of SystemConfig containing all controls for
54 particular Servod invocation
55 vendor: usb vendor id of FTDI device
56 product: usb product id of FTDI device
Todd Brochad034442011-05-25 15:05:29 -070057 serialname: string of device serialname/number as defined in FTDI eeprom.
Todd Brochdbb09982011-10-02 07:14:26 -070058 interfaces: list of strings of interface types the server will instantiate
Simran Basia23c1392013-08-06 14:59:10 -070059 version: String. Servo board version. Examples: servo_v1, servo_v2,
60 servo_v2_r0, servo_v3
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -080061 usbkm232: String. Optional. Path to USB-KM232 device which allow for
62 sending keyboard commands to DUTs that do not have built in
63 keyboards. Used in FAFT tests.
64 e.g. /dev/ttyUSB0
Todd Brochdbb09982011-10-02 07:14:26 -070065
66 Raises:
67 ServodError: if unable to locate init method for particular interface
Todd Broche505b8d2011-03-21 18:19:54 -070068 """
69 self._logger = logging.getLogger("Servod")
70 self._logger.debug("")
71 self._vendor = vendor
72 self._product = product
Todd Brochad034442011-05-25 15:05:29 -070073 self._serialname = serialname
Todd Broche505b8d2011-03-21 18:19:54 -070074 self._syscfg = config
75 # list of objects (Fi2c, Fgpio) to physical interfaces (gpio, i2c) that ftdi
76 # interfaces are mapped to
77 self._interface_list = []
78 # Dict of Dict to map control name, function name to to tuple (params, drv)
79 # Ex) _drv_dict[name]['get'] = (params, drv)
80 self._drv_dict = {}
J. Richard Barnettee2820552013-03-14 16:13:46 -070081 self._board = board
Simran Basia23c1392013-08-06 14:59:10 -070082 self._version = version
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -080083 self._usbkm232 = usbkm232
84
85 self._keyboard = self._init_keyboard_handler(self, self._board)
Todd Broche505b8d2011-03-21 18:19:54 -070086
Todd Brochdbb09982011-10-02 07:14:26 -070087 # Note, interface i is (i - 1) in list
88 if not interfaces:
Todd Brochb21d8042014-05-15 12:54:54 -070089 try:
90 interfaces = servo_interfaces.INTERFACE_BOARDS[board][vendor][product]
91 except KeyError:
92 interfaces = servo_interfaces.INTERFACE_DEFAULTS[vendor][product]
Todd Brochdbb09982011-10-02 07:14:26 -070093
Simran Basia9ad25e2013-04-23 11:57:00 -070094 for i, interface in enumerate(interfaces):
95 is_ftdi_interface = False
96 if type(interface) is dict:
97 name = interface['name']
98 elif type(interface) is str:
99 # Its FTDI related interface
100 name = interface
101 interface = (i % ftdi_common.MAX_FTDI_INTERFACES_PER_DEVICE) + 1
102 is_ftdi_interface = True
103 else:
104 raise ServodError("Illegal interface type %s" % type(interface))
105
Todd Broch8a77a992012-01-27 09:46:08 -0800106 # servos with multiple FTDI are guaranteed to have contiguous USB PIDs
Simran Basia9ad25e2013-04-23 11:57:00 -0700107 if is_ftdi_interface and i and \
108 ((i % ftdi_common.MAX_FTDI_INTERFACES_PER_DEVICE) == 0):
Todd Broch8a77a992012-01-27 09:46:08 -0800109 self._product += 1
110 self._logger.info("Changing to next FTDI part @ pid = 0x%04x",
111 self._product)
112
Simran Basia9ad25e2013-04-23 11:57:00 -0700113 self._logger.info("Initializing interface %d to %s", i + 1, name)
Todd Brochdbb09982011-10-02 07:14:26 -0700114 try:
115 func = getattr(self, '_init_%s' % name)
116 except AttributeError:
117 raise ServodError("Unable to locate init for interface %s" % name)
Simran Basia9ad25e2013-04-23 11:57:00 -0700118 result = func(interface)
Todd Broch888da782011-10-07 14:29:09 -0700119 if isinstance(result, tuple):
120 self._interface_list.extend(result)
121 else:
122 self._interface_list.append(result)
Todd Broche505b8d2011-03-21 18:19:54 -0700123
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -0800124 def _init_keyboard_handler(self, servo, board=''):
125 """Initialize the correct keyboard handler for board.
126
127 @param servo: servo object.
128 @param board: string, board name.
129
130 """
131 if board == 'parrot':
132 return keyboard_handlers.ParrotHandler(servo)
133 elif board == 'stout':
134 return keyboard_handlers.StoutHandler(servo)
davidfae09582015-01-15 10:32:59 +0800135 elif board in ('cranky', 'guado', 'jecht', 'mccloud', 'monroe',
Ted Kuobb7254e2015-03-17 10:20:09 +0800136 'ninja', 'nyan_kitty', 'panther', 'rikku', 'sumo',
137 'tidus', 'tricky', 'zako'):
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -0800138 if self._usbkm232 is None:
Yusuf Mohsinally66844692014-05-22 10:37:52 -0700139 logging.warn("No device path specified for usbkm232 handler. Returning "
140 "the DefaultHandler, which is likely the wrong keyboard "
141 "handler for the board type specified.")
142 return keyboard_handlers.DefaultHandler(servo)
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -0800143 return keyboard_handlers.USBkm232Handler(servo, self._usbkm232)
144 else:
145 return keyboard_handlers.DefaultHandler(servo)
146
Todd Broch3ec8df02012-11-20 10:53:03 -0800147 def __del__(self):
148 """Servod deconstructor."""
149 for interface in self._interface_list:
150 del(interface)
151
Todd Brochb3048492012-01-15 21:52:41 -0800152 def _init_dummy(self, interface):
153 """Initialize dummy interface.
154
155 Dummy interface is just a mechanism to reserve that interface for non servod
156 interaction. Typically the interface will be managed by external
157 third-party tools like openOCD or urjtag for JTAG or flashrom for SPI
158 interfaces.
159
160 TODO(tbroch): Investigate merits of incorporating these third-party
161 interfaces into servod or creating a communication channel between them
162
163 Returns: None
164 """
165 return None
166
Simran Basie750a342013-03-12 13:45:26 -0700167 def _init_ftdi_gpio(self, interface):
Todd Broche505b8d2011-03-21 18:19:54 -0700168 """Initialize gpio driver interface and open for use.
169
170 Args:
171 interface: interface number of FTDI device to use.
172
173 Returns:
174 Instance object of interface.
Todd Broch6de9dc62012-04-09 15:23:53 -0700175
176 Raises:
177 ServodError: If init fails
Todd Broche505b8d2011-03-21 18:19:54 -0700178 """
Todd Brochad034442011-05-25 15:05:29 -0700179 fobj = ftdigpio.Fgpio(self._vendor, self._product, interface,
180 self._serialname)
Todd Broch6de9dc62012-04-09 15:23:53 -0700181 try:
182 fobj.open()
183 except ftdigpio.FgpioError as e:
184 raise ServodError('Opening gpio interface. %s ( %d )' % (e.msg, e.value))
185
Todd Broche505b8d2011-03-21 18:19:54 -0700186 return fobj
187
Aaron.Chuang88eff332014-07-31 08:32:00 +0800188 def _init_bb_adc(self, interface):
189 """Initalize beaglebone ADC interface."""
190 return bbadc.BBadc()
191
Simran Basie750a342013-03-12 13:45:26 -0700192 def _init_bb_gpio(self, interface):
193 """Initalize beaglebone gpio interface."""
Simran Basi5492bde2013-05-16 17:08:47 -0700194 return bbgpio.BBgpio()
Simran Basie750a342013-03-12 13:45:26 -0700195
196 def _init_ftdi_i2c(self, interface):
Todd Broche505b8d2011-03-21 18:19:54 -0700197 """Initialize i2c interface and open for use.
198
199 Args:
200 interface: interface number of FTDI device to use
201
202 Returns:
203 Instance object of interface
Todd Broch6de9dc62012-04-09 15:23:53 -0700204
205 Raises:
206 ServodError: If init fails
Todd Broche505b8d2011-03-21 18:19:54 -0700207 """
Todd Brochad034442011-05-25 15:05:29 -0700208 fobj = ftdii2c.Fi2c(self._vendor, self._product, interface,
209 self._serialname)
Todd Broch6de9dc62012-04-09 15:23:53 -0700210 try:
211 fobj.open()
212 except ftdii2c.Fi2cError as e:
213 raise ServodError('Opening i2c interface. %s ( %d )' % (e.msg, e.value))
214
Todd Broche505b8d2011-03-21 18:19:54 -0700215 # Set the frequency of operation of the i2c bus.
216 # TODO(tbroch) make configureable
217 fobj.setclock(MAX_I2C_CLOCK_HZ)
Todd Broch6de9dc62012-04-09 15:23:53 -0700218
Todd Broche505b8d2011-03-21 18:19:54 -0700219 return fobj
220
Simran Basie750a342013-03-12 13:45:26 -0700221 # TODO (sbasi) crbug.com/187489 - Implement bb_i2c.
222 def _init_bb_i2c(self, interface):
223 """Initalize beaglebone i2c interface."""
Simran Basia9ad25e2013-04-23 11:57:00 -0700224 return bbi2c.BBi2c(interface)
Simran Basie750a342013-03-12 13:45:26 -0700225
Rong Changc6c8c022014-08-11 14:07:11 +0800226 def _init_dev_i2c(self, interface):
227 """Initalize Linux i2c-dev interface."""
228 return i2cbus.I2CBus('/dev/i2c-%d' % interface['bus_num'])
229
Simran Basie750a342013-03-12 13:45:26 -0700230 def _init_ftdi_uart(self, interface):
231 """Initialize ftdi uart inteface and open for use
Todd Broch47c43f42011-05-26 15:11:31 -0700232
233 Note, the uart runs in a separate thread (pthreads). Users wishing to
234 interact with it will query control for the pty's pathname and connect
235 with there favorite console program. For example:
236 cu -l /dev/pts/22
237
238 Args:
239 interface: interface number of FTDI device to use
240
241 Returns:
242 Instance object of interface
Todd Broch6de9dc62012-04-09 15:23:53 -0700243
244 Raises:
245 ServodError: If init fails
Todd Broch47c43f42011-05-26 15:11:31 -0700246 """
Jeremy Thorpe9e110062012-10-25 10:40:00 -0700247 fobj = ftdiuart.Fuart(self._vendor, self._product, interface,
248 self._serialname)
Todd Broch6de9dc62012-04-09 15:23:53 -0700249 try:
250 fobj.run()
251 except ftdiuart.FuartError as e:
252 raise ServodError('Running uart interface. %s ( %d )' % (e.msg, e.value))
253
Todd Broch47c43f42011-05-26 15:11:31 -0700254 self._logger.info("%s" % fobj.get_pty())
255 return fobj
256
Simran Basie750a342013-03-12 13:45:26 -0700257 # TODO (sbasi) crbug.com/187492 - Implement bbuart.
258 def _init_bb_uart(self, interface):
259 """Initalize beaglebone uart interface."""
Simran Basi949309b2013-05-31 15:12:15 -0700260 logging.debug('UART INTERFACE: %s', interface)
261 return bbuart.BBuart(interface)
Simran Basie750a342013-03-12 13:45:26 -0700262
263 def _init_ftdi_gpiouart(self, interface):
Todd Broch888da782011-10-07 14:29:09 -0700264 """Initialize special gpio + uart interface and open for use
265
266 Note, the uart runs in a separate thread (pthreads). Users wishing to
267 interact with it will query control for the pty's pathname and connect
268 with there favorite console program. For example:
269 cu -l /dev/pts/22
270
271 Args:
272 interface: interface number of FTDI device to use
273
274 Returns:
275 Instance objects of interface
Todd Broch6de9dc62012-04-09 15:23:53 -0700276
277 Raises:
278 ServodError: If init fails
Todd Broch888da782011-10-07 14:29:09 -0700279 """
Simran Basie750a342013-03-12 13:45:26 -0700280 fgpio = self._init_ftdi_gpio(interface)
Jeremy Thorpe9e110062012-10-25 10:40:00 -0700281 fuart = ftdiuart.Fuart(self._vendor, self._product, interface,
282 self._serialname, fgpio._fc)
Todd Broch6de9dc62012-04-09 15:23:53 -0700283 try:
284 fuart.run()
285 except ftdiuart.FuartError as e:
286 raise ServodError('Running uart interface. %s ( %d )' % (e.msg, e.value))
287
Todd Broch888da782011-10-07 14:29:09 -0700288 self._logger.info("uart pty: %s" % fuart.get_pty())
289 return fgpio, fuart
290
Tom Wai-Hong Tam28f0a5f2012-08-21 12:49:57 +0800291 def _camel_case(self, string):
292 output = ''
293 for s in string.split('_'):
294 if output:
295 output += s.capitalize()
296 else:
297 output = s
298 return output
299
Todd Broche505b8d2011-03-21 18:19:54 -0700300 def _get_param_drv(self, control_name, is_get=True):
301 """Get access to driver for a given control.
302
303 Note, some controls have different parameter dictionaries for 'getting' the
304 control's value versus 'setting' it. Boolean is_get distinguishes which is
305 being requested.
306
307 Args:
308 control_name: string name of control
309 is_get: boolean to determine
310
311 Returns:
312 tuple (param, drv) where:
313 param: param dictionary for control
314 drv: instance object of driver for particular control
315
316 Raises:
317 ServodError: Error occurred while examining params dict
318 """
319 self._logger.debug("")
320 # if already setup just return tuple from driver dict
321 if control_name in self._drv_dict:
322 if is_get and ('get' in self._drv_dict[control_name]):
323 return self._drv_dict[control_name]['get']
324 if not is_get and ('set' in self._drv_dict[control_name]):
325 return self._drv_dict[control_name]['set']
326
327 params = self._syscfg.lookup_control_params(control_name, is_get)
328 if 'drv' not in params:
329 self._logger.error("Unable to determine driver for %s" % control_name)
330 raise ServodError("'drv' key not found in params dict")
331 if 'interface' not in params:
332 self._logger.error("Unable to determine interface for %s" %
333 control_name)
Todd Broche505b8d2011-03-21 18:19:54 -0700334 raise ServodError("'interface' key not found in params dict")
Simran Basi668be0e2013-08-07 11:54:50 -0700335
J. Richard Barnette275d9fd2014-02-11 14:38:54 -0800336 interface_id = params.get(
337 '%s_interface' % self._version, params['interface'])
338 if interface_id == 'servo':
339 interface = self
Simran Basi668be0e2013-08-07 11:54:50 -0700340 else:
J. Richard Barnette275d9fd2014-02-11 14:38:54 -0800341 index = int(interface_id) - 1
342 interface = self._interface_list[index]
Simran Basi668be0e2013-08-07 11:54:50 -0700343
Todd Broche505b8d2011-03-21 18:19:54 -0700344 servo_pkg = imp.load_module('servo', *imp.find_module('servo'))
345 drv_pkg = imp.load_module('drv',
346 *imp.find_module('drv', servo_pkg.__path__))
347 drv_name = params['drv']
348 drv_module = getattr(drv_pkg, drv_name)
Tom Wai-Hong Tam28f0a5f2012-08-21 12:49:57 +0800349 drv_class = getattr(drv_module, self._camel_case(drv_name))
Todd Broche505b8d2011-03-21 18:19:54 -0700350 drv = drv_class(interface, params)
351 if control_name not in self._drv_dict:
352 self._drv_dict[control_name] = {}
353 if is_get:
354 self._drv_dict[control_name]['get'] = (params, drv)
355 else:
356 self._drv_dict[control_name]['set'] = (params, drv)
357 return (params, drv)
358
359 def doc_all(self):
360 """Return all documenation for controls.
361
362 Returns:
363 string of <doc> text in config file (xml) and the params dictionary for
364 all controls.
365
366 For example:
367 warm_reset :: Reset the device warmly
368 ------------------------> {'interface': '1', 'map': 'onoff_i', ... }
369 """
370 return self._syscfg.display_config()
371
372 def doc(self, name):
373 """Retreive doc string in system config file for given control name.
374
375 Args:
376 name: name string of control to get doc string
377
378 Returns:
379 doc string of name
380
381 Raises:
382 NameError: if fails to locate control
383 """
384 self._logger.debug("name(%s)" % (name))
385 if self._syscfg.is_control(name):
386 return self._syscfg.get_control_docstring(name)
387 else:
388 raise NameError("No control %s" %name)
389
Fang Deng90377712013-06-03 15:51:48 -0700390 def _switch_usbkey(self, mux_direction):
391 """Connect USB flash stick to either servo or DUT.
392
393 This function switches 'usb_mux_sel1' to provide electrical
394 connection between the USB port J3 and either servo or DUT side.
395
396 Switching the usb mux is accompanied by powercycling
397 of the USB stick, because it sometimes gets wedged if the mux
398 is switched while the stick power is on.
399
400 Args:
401 mux_direction: "servo_sees_usbkey" or "dut_sees_usbkey".
402 """
403 self.set(self._USB_J3_PWR, self._USB_J3_PWR_OFF)
404 time.sleep(self._USB_POWEROFF_DELAY)
405 self.set(self._USB_J3, mux_direction)
406 time.sleep(self._USB_POWEROFF_DELAY)
407 self.set(self._USB_J3_PWR, self._USB_J3_PWR_ON)
408 if mux_direction == self._USB_J3_TO_SERVO:
409 time.sleep(self._USB_DETECTION_DELAY)
410
Simran Basia9f41032012-05-11 14:21:58 -0700411 def _get_usb_port_set(self):
412 """Gets a set of USB disks currently connected to the system
413
414 Returns:
415 A set of USB disk paths.
416 """
417 usb_set = fnmatch.filter(os.listdir("/dev/"), "sd[a-z]")
418 return set(["/dev/" + dev for dev in usb_set])
419
420 def _probe_host_usb_dev(self):
421 """Probe the USB disk device plugged in the servo from the host side.
422
423 Method can fail by:
424 1) Having multiple servos connected and returning incorrect /dev/sdX of
425 another servo.
426 2) Finding multiple /dev/sdX and returning None.
427
428 Returns:
429 USB disk path if one and only one USB disk path is found, otherwise None.
430 """
Fang Deng90377712013-06-03 15:51:48 -0700431 original_value = self.get(self._USB_J3)
432 original_usb_power = self.get(self._USB_J3_PWR)
Simran Basia9f41032012-05-11 14:21:58 -0700433 # Make the host unable to see the USB disk.
Fang Deng90377712013-06-03 15:51:48 -0700434 if (original_usb_power == self._USB_J3_PWR_ON and
435 original_value != self._USB_J3_TO_DUT):
436 self._switch_usbkey(self._USB_J3_TO_DUT)
Simran Basia9f41032012-05-11 14:21:58 -0700437 no_usb_set = self._get_usb_port_set()
Simran Basia9f41032012-05-11 14:21:58 -0700438
Fang Deng90377712013-06-03 15:51:48 -0700439 # Make the host able to see the USB disk.
440 self._switch_usbkey(self._USB_J3_TO_SERVO)
Simran Basia9f41032012-05-11 14:21:58 -0700441 has_usb_set = self._get_usb_port_set()
Fang Deng90377712013-06-03 15:51:48 -0700442
Simran Basia9f41032012-05-11 14:21:58 -0700443 # Back to its original value.
Fang Deng90377712013-06-03 15:51:48 -0700444 if original_value != self._USB_J3_TO_SERVO:
445 self._switch_usbkey(original_value)
446 if original_usb_power != self._USB_J3_PWR_ON:
447 self.set(self._USB_J3_PWR, self._USB_J3_PWR_OFF)
448 time.sleep(self._USB_POWEROFF_DELAY)
449
Simran Basia9f41032012-05-11 14:21:58 -0700450 # Subtract the two sets to find the usb device.
451 diff_set = has_usb_set - no_usb_set
452 if len(diff_set) == 1:
453 return diff_set.pop()
454 else:
455 return None
456
457 def download_image_to_usb(self, image_path):
458 """Download image and save to the USB device found by probe_host_usb_dev.
459 If the image_path is a URL, it will download this url to the USB path;
460 otherwise it will simply copy the image_path's contents to the USB path.
461
462 Args:
463 image_path: path or url to the recovery image.
464
465 Returns:
466 True|False: True if process completed successfully, False if error
467 occurred.
468 Can't return None because XMLRPC doesn't allow it. PTAL at tbroch's
469 comment at the end of set().
470 """
471 self._logger.debug("image_path(%s)" % image_path)
472 self._logger.debug("Detecting USB stick device...")
473 usb_dev = self._probe_host_usb_dev()
474 if not usb_dev:
475 self._logger.error("No usb device connected to servo")
476 return False
477
478 try:
479 if image_path.startswith(self._HTTP_PREFIX):
480 self._logger.debug("Image path is a URL, downloading image")
481 urllib.urlretrieve(image_path, usb_dev)
482 else:
483 shutil.copyfile(image_path, usb_dev)
484 except IOError as e:
485 self._logger.error("Failed to transfer image to USB device: %s ( %d ) ",
486 e.strerror, e.errno)
487 return False
488 except urllib.ContentTooShortError:
489 self._logger.error("Failed to download URL: %s to USB device: %s",
490 image_path, usb_dev)
491 return False
492 except BaseException as e:
493 self._logger.error("Unexpected exception downloading %s to %s: %s",
494 image_path, usb_dev, str(e))
495 return False
J. Richard Barnettee4125af2013-02-26 18:31:56 -0800496 finally:
497 # We just plastered the partition table for a block device.
498 # Pass or fail, we mustn't go without telling the kernel about
499 # the change, or it will punish us with sporadic, hard-to-debug
500 # failures.
501 subprocess.call(["sync"])
502 subprocess.call(["blockdev", "--rereadpt", usb_dev])
Simran Basia9f41032012-05-11 14:21:58 -0700503 return True
504
505 def make_image_noninteractive(self):
506 """Makes the recovery image noninteractive.
507
508 A noninteractive image will reboot automatically after installation
509 instead of waiting for the USB device to be removed to initiate a system
510 reboot.
511
512 Mounts partition 1 of the image stored on usb_dev and creates a file
513 called "non_interactive" so that the image will become noninteractive.
514
515 Returns:
516 True|False: True if process completed successfully, False if error
517 occurred.
518 """
519 result = True
520 usb_dev = self._probe_host_usb_dev()
521 if not usb_dev:
522 self._logger.error("No usb device connected to servo")
523 return False
524 # Create TempDirectory
525 tmpdir = tempfile.mkdtemp()
526 if tmpdir:
527 # Mount drive to tmpdir.
528 partition_1 = "%s1" % usb_dev
529 rc = subprocess.call(["mount", partition_1, tmpdir])
530 if rc == 0:
531 # Create file 'non_interactive'
532 non_interactive_file = os.path.join(tmpdir, "non_interactive")
533 try:
534 open(non_interactive_file, "w").close()
535 except IOError as e:
536 self._logger.error("Failed to create file %s : %s ( %d )",
537 non_interactive_file, e.strerror, e.errno)
538 result = False
539 except BaseException as e:
540 self._logger.error("Unexpected Exception creating file %s : %s",
541 non_interactive_file, str(e))
542 result = False
543 # Unmount drive regardless if file creation worked or not.
544 rc = subprocess.call(["umount", partition_1])
545 if rc != 0:
546 self._logger.error("Failed to unmount USB Device")
547 result = False
548 else:
549 self._logger.error("Failed to mount USB Device")
550 result = False
551
552 # Delete tmpdir. May throw exception if 'umount' failed.
553 try:
554 os.rmdir(tmpdir)
555 except OSError as e:
556 self._logger.error("Failed to remove temp directory %s : %s",
557 tmpdir, str(e))
558 return False
559 except BaseException as e:
560 self._logger.error("Unexpected Exception removing tempdir %s : %s",
561 tmpdir, str(e))
562 return False
563 else:
564 self._logger.error("Failed to create temp directory.")
565 return False
566 return result
567
Todd Broch352b4b22013-03-22 09:48:40 -0700568 def set_get_all(self, cmds):
569 """Set &| get one or more control values.
570
571 Args:
572 cmds: list of control[:value] to get or set.
573
574 Returns:
575 rv: list of responses from calling get or set methods.
576 """
577 rv = []
578 for cmd in cmds:
579 if ':' in cmd:
580 (control, value) = cmd.split(':')
581 rv.append(self.set(control, value))
582 else:
583 rv.append(self.get(cmd))
584 return rv
585
Todd Broche505b8d2011-03-21 18:19:54 -0700586 def get(self, name):
587 """Get control value.
588
589 Args:
590 name: name string of control
591
592 Returns:
593 Response from calling drv get method. Value is reformatted based on
594 control's dictionary parameters
595
596 Raises:
597 HwDriverError: Error occurred while using drv
598 """
599 self._logger.debug("name(%s)" % (name))
600 (param, drv) = self._get_param_drv(name)
601 try:
602 val = drv.get()
603 rd_val = self._syscfg.reformat_val(param, val)
Todd Brochb042e7a2011-12-14 17:41:36 -0800604 self._logger.debug("%s = %s" % (name, rd_val))
Todd Broche505b8d2011-03-21 18:19:54 -0700605 return rd_val
Todd Brochfbc499d2011-06-16 16:09:58 -0700606 except AttributeError, error:
607 self._logger.error("Getting %s: %s" % (name, error))
608 raise
Vic Yangbe6cf262012-09-10 10:40:56 +0800609 except HwDriverError:
Todd Broche505b8d2011-03-21 18:19:54 -0700610 self._logger.error("Getting %s" % (name))
611 raise
Todd Brochd6061672012-05-11 15:52:47 -0700612
Todd Broche505b8d2011-03-21 18:19:54 -0700613 def get_all(self, verbose):
614 """Get all controls values.
615
616 Args:
617 verbose: Boolean on whether to return doc info as well
618
619 Returns:
620 string creating from trying to get all values of all controls. In case of
621 error attempting access to control, response is 'ERR'.
622 """
Vadim Bendeburyb07944c2013-01-16 10:47:10 -0800623 rsp = []
Todd Broche505b8d2011-03-21 18:19:54 -0700624 for name in self._syscfg.syscfg_dict['control']:
625 self._logger.debug("name = %s" %name)
626 try:
627 value = self.get(name)
628 except Exception:
629 value = "ERR"
630 pass
631 if verbose:
Vadim Bendeburyb07944c2013-01-16 10:47:10 -0800632 rsp.append("GET %s = %s :: %s" % (name, value, self.doc(name)))
Todd Broche505b8d2011-03-21 18:19:54 -0700633 else:
Vadim Bendeburyb07944c2013-01-16 10:47:10 -0800634 rsp.append("%s:%s" % (name, value))
635 return '\n'.join(sorted(rsp))
Todd Broche505b8d2011-03-21 18:19:54 -0700636
637 def set(self, name, wr_val_str):
638 """Set control.
639
640 Args:
641 name: name string of control
642 wr_val_str: value string to write. Can be integer, float or a
643 alpha-numerical that is mapped to a integer or float.
644
645 Raises:
646 HwDriverError: Error occurred while using driver
647 """
648 self._logger.debug("name(%s) wr_val(%s)" % (name, wr_val_str))
649 (params, drv) = self._get_param_drv(name, False)
650 wr_val = self._syscfg.resolve_val(params, wr_val_str)
651 try:
652 drv.set(wr_val)
Vic Yangbe6cf262012-09-10 10:40:56 +0800653 except HwDriverError:
Todd Broche505b8d2011-03-21 18:19:54 -0700654 self._logger.error("Setting %s -> %s" % (name, wr_val_str))
655 raise
656 # TODO(tbroch) Figure out why despite allow_none=True for both xmlrpc server
657 # & client I still have to return something to appease the
658 # marshall/unmarshall
659 return True
660
Todd Brochd6061672012-05-11 15:52:47 -0700661 def hwinit(self, verbose=False):
662 """Initialize all controls.
663
664 These values are part of the system config XML files of the form
665 init=<value>. This command should be used by clients wishing to return the
666 servo and DUT its connected to a known good/safe state.
667
Vadim Bendeburybb51dd42013-01-31 13:47:46 -0800668 Note that initialization errors are ignored (as in some cases they could
669 be caused by DUT firmware deficiencies). This might need to be fine tuned
670 later.
671
Todd Brochd6061672012-05-11 15:52:47 -0700672 Args:
673 verbose: boolean, if True prints info about control initialized.
674 Otherwise prints nothing.
Vadim Bendebury5934e4b2013-02-06 13:57:54 -0800675
676 Returns:
677 This function is called across RPC and as such is expected to return
678 something unless transferring 'none' across is allowed. Hence adding a
679 dummy return value to make things simpler.
Todd Brochd6061672012-05-11 15:52:47 -0700680 """
Todd Brochd9acf0a2012-12-05 13:43:06 -0800681 for control_name, value in self._syscfg.hwinit:
Todd Broch3ec8df02012-11-20 10:53:03 -0800682 try:
683 self.set(control_name, value)
684 except Exception as e:
Todd Broch3ec8df02012-11-20 10:53:03 -0800685 self._logger.error("Problem initializing %s -> %s :: %s",
686 control_name, value, str(e))
Todd Brochd6061672012-05-11 15:52:47 -0700687 if verbose:
688 self._logger.info('Initialized %s to %s', control_name, value)
Vadim Bendebury5934e4b2013-02-06 13:57:54 -0800689 return True
Todd Broch3ec8df02012-11-20 10:53:03 -0800690
Todd Broche505b8d2011-03-21 18:19:54 -0700691 def echo(self, echo):
692 """Dummy echo function for testing/examples.
693
694 Args:
695 echo: string to echo back to client
696 """
697 self._logger.debug("echo(%s)" % (echo))
698 return "ECH0ING: %s" % (echo)
699
J. Richard Barnettee2820552013-03-14 16:13:46 -0700700 def get_board(self):
701 """Return the board specified at startup, if any."""
702 return self._board
703
Simran Basia23c1392013-08-06 14:59:10 -0700704 def get_version(self):
705 """Get servo board version."""
706 return self._version
707
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -0800708 def power_long_press(self):
709 """Simulate a long power button press."""
710 # After a long power press, the EC may ignore the next power
711 # button press (at least on Alex). To guarantee that this
712 # won't happen, we need to allow the EC one second to
713 # collect itself.
714 self._keyboard.power_long_press()
715 return True
716
717 def power_normal_press(self):
718 """Simulate a normal power button press."""
719 self._keyboard.power_normal_press()
720 return True
721
722 def power_short_press(self):
723 """Simulate a short power button press."""
724 self._keyboard.power_short_press()
725 return True
726
727 def power_key(self, secs=''):
728 """Simulate a power button press.
729
730 Args:
731 secs: Time in seconds to simulate the keypress.
732 """
733 self._keyboard.power_key(secs)
734 return True
735
736 def ctrl_d(self, press_secs=''):
737 """Simulate Ctrl-d simultaneous button presses."""
738 self._keyboard.ctrl_d(press_secs)
739 return True
740
741 def ctrl_u(self):
742 """Simulate Ctrl-u simultaneous button presses."""
743 self._keyboard.ctrl_u()
744 return True
745
746 def ctrl_enter(self, press_secs=''):
747 """Simulate Ctrl-enter simultaneous button presses."""
748 self._keyboard.ctrl_enter(press_secs)
749 return True
750
751 def d_key(self, press_secs=''):
752 """Simulate Enter key button press."""
753 self._keyboard.d_key(press_secs)
754 return True
755
756 def ctrl_key(self, press_secs=''):
757 """Simulate Enter key button press."""
758 self._keyboard.ctrl_key(press_secs)
759 return True
760
761 def enter_key(self, press_secs=''):
762 """Simulate Enter key button press."""
763 self._keyboard.enter_key(press_secs)
764 return True
765
766 def refresh_key(self, press_secs=''):
767 """Simulate Refresh key (F3) button press."""
768 self._keyboard.refresh_key(press_secs)
769 return True
770
771 def ctrl_refresh_key(self, press_secs=''):
772 """Simulate Ctrl and Refresh (F3) simultaneous press.
773
774 This key combination is an alternative of Space key.
775 """
776 self._keyboard.ctrl_refresh_key(press_secs)
777 return True
778
779 def imaginary_key(self, press_secs=''):
780 """Simulate imaginary key button press.
781
782 Maps to a key that doesn't physically exist.
783 """
784 self._keyboard.imaginary_key(press_secs)
785 return True
786
Todd Brochdbb09982011-10-02 07:14:26 -0700787
Todd Broche505b8d2011-03-21 18:19:54 -0700788def test():
789 """Integration testing.
790
791 TODO(tbroch) Enhance integration test and add unittest (see mox)
792 """
793 logging.basicConfig(level=logging.DEBUG,
794 format="%(asctime)s - %(name)s - " +
795 "%(levelname)s - %(message)s")
796 # configure server & listen
797 servod_obj = Servod(1)
798 # 4 == number of interfaces on a FT4232H device
799 for i in xrange(4):
800 if i == 1:
801 # its an i2c interface ... see __init__ for details and TODO to make
802 # this configureable
803 servod_obj._interface_list[i].wr_rd(0x21, [0], 1)
804 else:
805 # its a gpio interface
806 servod_obj._interface_list[i].wr_rd(0)
807
808 server = SimpleXMLRPCServer.SimpleXMLRPCServer(("localhost", 9999),
809 allow_none=True)
810 server.register_introspection_functions()
811 server.register_multicall_functions()
812 server.register_instance(servod_obj)
813 logging.info("Listening on localhost port 9999")
814 server.serve_forever()
815
816if __name__ == "__main__":
817 test()
818
819 # simple client transaction would look like
820 """
821 remote_uri = 'http://localhost:9999'
822 client = xmlrpclib.ServerProxy(remote_uri, verbose=False)
823 send_str = "Hello_there"
824 print "Sent " + send_str + ", Recv " + client.echo(send_str)
825 """