blob: 194bfde9e3bd24b71eaadd1a97e0413c56f3a96a [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."""
Kevin Chengc49494e2016-07-25 12:13:38 -07005import datetime
6import fcntl
Simran Basia9f41032012-05-11 14:21:58 -07007import fnmatch
Todd Broche505b8d2011-03-21 18:19:54 -07008import logging
Simran Basia9f41032012-05-11 14:21:58 -07009import os
Aseda Aboagye1d8477b2017-05-10 17:24:31 -070010import re
Todd Broche505b8d2011-03-21 18:19:54 -070011import SimpleXMLRPCServer
Ruben Rodriguez Buchillona5d8b922018-09-03 16:51:03 +080012import threading
Todd Broch7a91c252012-02-03 12:37:45 -080013import time
Wai-Hong Tam1f9e9a72017-05-02 14:14:46 -070014import usb
Todd Broche505b8d2011-03-21 18:19:54 -070015
Wai-Hong Tam4c09eff2017-02-17 11:46:19 -080016import drv as servo_drv
Aaron.Chuang88eff332014-07-31 08:32:00 +080017import bbadc
Simran Basia9ad25e2013-04-23 11:57:00 -070018import bbi2c
Simran Basi5492bde2013-05-16 17:08:47 -070019import bbgpio
Simran Basi949309b2013-05-31 15:12:15 -070020import bbuart
Aseda Aboagyea4922212015-11-20 15:19:08 -080021import ec3po_interface
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
Kevin Cheng16304d12016-07-08 11:56:55 -070029import servo_postinit
Nick Sanders97bc4462016-01-04 15:37:31 -080030import stm32gpio
31import stm32i2c
32import stm32uart
Todd Broche505b8d2011-03-21 18:19:54 -070033
Wai-Hong Tam4c09eff2017-02-17 11:46:19 -080034HwDriverError = servo_drv.hw_driver.HwDriverError
Aseda Aboagyea4922212015-11-20 15:19:08 -080035
Todd Broche505b8d2011-03-21 18:19:54 -070036MAX_I2C_CLOCK_HZ = 100000
37
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -070038
Todd Broche505b8d2011-03-21 18:19:54 -070039class ServodError(Exception):
40 """Exception class for servod."""
41
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -070042
Todd Broche505b8d2011-03-21 18:19:54 -070043class Servod(object):
44 """Main class for Servo debug/controller Daemon."""
Simran Basia9f41032012-05-11 14:21:58 -070045
Kevin Cheng4b4f0022016-09-09 02:37:07 -070046 # This is the key to get the main serial used in the _serialnames dict.
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -070047 MAIN_SERIAL = 'main'
48 SERVO_MICRO_SERIAL = 'servo_micro'
49 CCD_SERIAL = 'ccd'
Kevin Cheng4b4f0022016-09-09 02:37:07 -070050
Ruben Rodriguez Buchillona5d8b922018-09-03 16:51:03 +080051 # Timeout to wait for interfaces to become available again if reinitialization
52 # is taking place. In seconds.
53 INTERFACE_AVAILABILITY_TIMEOUT = 60
54
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -070055 def init_servo_interfaces(self, vendor, product, serialname, interfaces):
Kevin Chengdc3befd2016-07-15 12:34:00 -070056 """Init the servo interfaces with the given interfaces.
57
58 We don't use the self._{vendor,product,serialname} attributes because we
59 want to allow other callers to initialize other interfaces that may not
60 be associated with the initialized attributes (e.g. a servo v4 servod object
61 that wants to also initialize a servo micro interface).
62
63 Args:
64 vendor: USB vendor id of FTDI device.
65 product: USB product id of FTDI device.
66 serialname: String of device serialname/number as defined in FTDI
67 eeprom.
68 interfaces: List of strings of interface types the server will
69 instantiate.
70
71 Raises:
72 ServodError if unable to locate init method for particular interface.
73 """
Mary Ruthven13389642017-02-14 12:15:34 -080074 # If it is a new device add it to the list
Wai-Hong Tam1f9e9a72017-05-02 14:14:46 -070075 device = (vendor, product, serialname)
Mary Ruthven13389642017-02-14 12:15:34 -080076 if device not in self._devices:
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -070077 self._devices.append(device)
Mary Ruthven13389642017-02-14 12:15:34 -080078
Kevin Chengdc3befd2016-07-15 12:34:00 -070079 # Extend the interface list if we need to.
80 interfaces_len = len(interfaces)
81 interface_list_len = len(self._interface_list)
82 if interfaces_len > interface_list_len:
83 self._interface_list += [None] * (interfaces_len - interface_list_len)
84
Kevin Chengdc3befd2016-07-15 12:34:00 -070085 for i, interface in enumerate(interfaces):
86 is_ftdi_interface = False
87 if type(interface) is dict:
88 name = interface['name']
89 # Store interface index for those that care about it.
90 interface['index'] = i
91 elif type(interface) is str and interface != 'dummy':
92 name = interface
Wai-Hong Tam564c1702017-04-24 09:23:38 -070093 # It's a FTDI related interface. #0 is reserved for no use.
94 interface = ((i - 1) % ftdi_common.MAX_FTDI_INTERFACES_PER_DEVICE) + 1
Kevin Chengdc3befd2016-07-15 12:34:00 -070095 is_ftdi_interface = True
96 elif type(interface) is str and interface == 'dummy':
97 # 'dummy' reserves the interface for future use. Typically the
98 # interface will be managed by external third-party tools like
99 # openOCD for JTAG or flashrom for SPI. In the case of servo V4,
100 # it serves as a placeholder for servo micro interfaces.
101 continue
102 else:
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700103 raise ServodError('Illegal interface type %s' % type(interface))
Kevin Chengdc3befd2016-07-15 12:34:00 -0700104
105 # servos with multiple FTDI are guaranteed to have contiguous USB PIDs
Wai-Hong Tam564c1702017-04-24 09:23:38 -0700106 product_increment = 0
107 if is_ftdi_interface:
108 product_increment = (i - 1) / ftdi_common.MAX_FTDI_INTERFACES_PER_DEVICE
109 if product_increment:
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700110 self._logger.info('Use the next FTDI part @ pid = 0x%04x',
Wai-Hong Tam564c1702017-04-24 09:23:38 -0700111 product + product_increment)
Kevin Chengdc3befd2016-07-15 12:34:00 -0700112
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700113 self._logger.info('Initializing interface %d to %s', i, name)
Kevin Chengdc3befd2016-07-15 12:34:00 -0700114 try:
115 func = getattr(self, '_init_%s' % name)
116 except AttributeError:
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700117 raise ServodError('Unable to locate init for interface %s' % name)
Wai-Hong Tam564c1702017-04-24 09:23:38 -0700118 result = func(vendor, product + product_increment, serialname, interface)
Kevin Chengdc3befd2016-07-15 12:34:00 -0700119
120 if isinstance(result, tuple):
121 result_len = len(result)
Wai-Hong Tamd8a94d62017-04-28 10:11:51 -0700122 self._interface_list[i:(i + result_len)] = result
Kevin Chengdc3befd2016-07-15 12:34:00 -0700123 else:
Wai-Hong Tamd8a94d62017-04-28 10:11:51 -0700124 self._interface_list[i] = result
Kevin Chengdc3befd2016-07-15 12:34:00 -0700125
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700126 def __init__(self, config, vendor, product, serialname=None, interfaces=None,
Namyoon Woo341a8332019-03-07 12:01:31 -0800127 board='', model='', version=None, usbkm232=None):
Todd Broche505b8d2011-03-21 18:19:54 -0700128 """Servod constructor.
129
130 Args:
131 config: instance of SystemConfig containing all controls for
132 particular Servod invocation
133 vendor: usb vendor id of FTDI device
134 product: usb product id of FTDI device
Todd Brochad034442011-05-25 15:05:29 -0700135 serialname: string of device serialname/number as defined in FTDI eeprom.
Todd Brochdbb09982011-10-02 07:14:26 -0700136 interfaces: list of strings of interface types the server will instantiate
Namyoon Woo341a8332019-03-07 12:01:31 -0800137 board: board name. e.g. octopus, coral, or scarlet.
138 model: model name of a given board. e.g. fleex, ampton, or apel.
Simran Basia23c1392013-08-06 14:59:10 -0700139 version: String. Servo board version. Examples: servo_v1, servo_v2,
140 servo_v2_r0, servo_v3
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -0800141 usbkm232: String. Optional. Path to USB-KM232 device which allow for
Kevin Chengdc3befd2016-07-15 12:34:00 -0700142 sending keyboard commands to DUTs that do not have built in
Wai-Hong Tam7b9f2992017-10-24 16:07:14 -0700143 keyboards. Used in FAFT tests. Use None for on board AVR MCU.
144 e.g. '/dev/ttyUSB0' or None.
Todd Brochdbb09982011-10-02 07:14:26 -0700145
146 Raises:
147 ServodError: if unable to locate init method for particular interface
Todd Broche505b8d2011-03-21 18:19:54 -0700148 """
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700149 self._logger = logging.getLogger('Servod')
150 self._logger.debug('')
Ruben Rodriguez Buchillona5d8b922018-09-03 16:51:03 +0800151 self._ifaces_available = threading.Event()
152 # Initially interfaces should be available.
153 self._ifaces_available.set()
Todd Broche505b8d2011-03-21 18:19:54 -0700154 self._vendor = vendor
155 self._product = product
Mary Ruthven13389642017-02-14 12:15:34 -0800156 self._devices = []
Kevin Cheng4b4f0022016-09-09 02:37:07 -0700157 self._serialnames = {self.MAIN_SERIAL: serialname}
Todd Broche505b8d2011-03-21 18:19:54 -0700158 self._syscfg = config
159 # list of objects (Fi2c, Fgpio) to physical interfaces (gpio, i2c) that ftdi
160 # interfaces are mapped to
161 self._interface_list = []
162 # Dict of Dict to map control name, function name to to tuple (params, drv)
163 # Ex) _drv_dict[name]['get'] = (params, drv)
164 self._drv_dict = {}
Wai-Hong Tam416cf612017-09-19 11:39:21 -0700165 self._base_board = ''
Namyoon Woo341a8332019-03-07 12:01:31 -0800166 self._board = board
167 if model:
168 self._board += '_' + model
169 self._model = model
Simran Basia23c1392013-08-06 14:59:10 -0700170 self._version = version
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -0800171 self._usbkm232 = usbkm232
Todd Brochdbb09982011-10-02 07:14:26 -0700172 if not interfaces:
Todd Brochb21d8042014-05-15 12:54:54 -0700173 try:
174 interfaces = servo_interfaces.INTERFACE_BOARDS[board][vendor][product]
175 except KeyError:
176 interfaces = servo_interfaces.INTERFACE_DEFAULTS[vendor][product]
Dino Lic89d8c82018-01-11 09:56:47 +0800177 self._interfaces = interfaces
Todd Brochdbb09982011-10-02 07:14:26 -0700178
Kevin Chengdc3befd2016-07-15 12:34:00 -0700179 self.init_servo_interfaces(vendor, product, serialname, interfaces)
Kevin Cheng16304d12016-07-08 11:56:55 -0700180 servo_postinit.post_init(self)
Danny Chan662b6022015-11-04 17:34:53 -0800181
Mary Ruthven13389642017-02-14 12:15:34 -0800182 def reinitialize(self):
183 """Reinitialize all interfaces that support reinitialization"""
Mary Ruthven13389642017-02-14 12:15:34 -0800184 for i, interface in enumerate(self._interface_list):
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700185 if hasattr(interface, 'reinitialize'):
186 interface.reinitialize()
187 else:
188 self._logger.debug('interface %d has no reset functionality', i)
Ruben Rodriguez Buchillona5d8b922018-09-03 16:51:03 +0800189 # Indicate interfaces are safe to use again.
190 self._ifaces_available.set()
Mary Ruthven13389642017-02-14 12:15:34 -0800191
Wai-Hong Tam4544c302017-05-24 19:44:53 -0700192 def get_servo_interfaces(self, position, size):
193 """Get the list of servo interfaces.
194
195 Args:
196 position: The index the first interface to get.
197 size: The number of the interfaces.
198 """
199 return self._interface_list[position:(position + size)]
200
201 def set_servo_interfaces(self, position, interfaces):
202 """Set the list of servo interfaces.
203
204 Args:
205 position: The index the first interface to set.
206 interfaces: The list of interfaces to set.
207 """
208 size = len(interfaces)
209 self._interface_list[position:(position + size)] = interfaces
210
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -0800211 def _init_keyboard_handler(self, servo, board=''):
212 """Initialize the correct keyboard handler for board.
213
Kevin Chengdc3befd2016-07-15 12:34:00 -0700214 Args:
215 servo: servo object.
216 board: string, board name.
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -0800217
Kevin Chengdc3befd2016-07-15 12:34:00 -0700218 Returns:
Wai-Hong Tam7b9f2992017-10-24 16:07:14 -0700219 keyboard handler object, or None if no keyboard supported.
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -0800220 """
221 if board == 'parrot':
222 return keyboard_handlers.ParrotHandler(servo)
223 elif board == 'stout':
224 return keyboard_handlers.StoutHandler(servo)
PeggyChuang4f07d872015-08-07 12:11:38 +0800225 elif board in ('buddy', 'cranky', 'guado', 'jecht', 'mccloud', 'monroe',
Duncan Lauriebc182ac2019-01-15 18:36:56 -0800226 'ninja', 'nyan_kitty', 'panther', 'rikku', 'sarien',
227 'stumpy', 'sumo', 'tidus', 'tricky', 'veyron_fievel',
228 'veyron_mickey', 'veyron_rialto', 'veyron_tiger', 'zako'):
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -0800229 if self._usbkm232 is None:
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700230 logging.info('No device path specified for usbkm232 handler. Use '
231 'the servo atmega chip to handle.')
Wai-Hong Tam7b9f2992017-10-24 16:07:14 -0700232
Danny Chan662b6022015-11-04 17:34:53 -0800233 # Use servo onboard keyboard emulator.
Wai-Hong Tam7b9f2992017-10-24 16:07:14 -0700234 if not self._syscfg.is_control('atmega_rst'):
235 logging.warn('No atmega in servo board. So no keyboard support.')
236 return None
237
Nick Sanders78423782015-11-09 14:28:19 -0800238 self.set('atmega_rst', 'on')
Nick Sandersbc836282015-12-08 21:19:23 -0800239 self.set('at_hwb', 'off')
Nick Sanders78423782015-11-09 14:28:19 -0800240 self.set('atmega_rst', 'off')
Danny Chan662b6022015-11-04 17:34:53 -0800241 self._usbkm232 = self.get('atmega_pty')
Wai-Hong Tam7b9f2992017-10-24 16:07:14 -0700242
Kevin Cheng810fc782016-11-01 12:36:46 -0700243 # We don't need to set the atmega uart settings if we're a servo v4.
Aseda Aboagye1d8477b2017-05-10 17:24:31 -0700244 if 'servo_v4' not in self._version:
Kevin Cheng810fc782016-11-01 12:36:46 -0700245 self.set('atmega_baudrate', '9600')
246 self.set('atmega_bits', 'eight')
247 self.set('atmega_parity', 'none')
248 self.set('atmega_sbits', 'one')
249 self.set('usb_mux_sel4', 'on')
250 self.set('usb_mux_oe4', 'on')
251 # Allow atmega bootup time.
252 time.sleep(1.0)
Wai-Hong Tam7b9f2992017-10-24 16:07:14 -0700253
Danny Chan662b6022015-11-04 17:34:53 -0800254 self._logger.info('USBKM232: %s', self._usbkm232)
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -0800255 return keyboard_handlers.USBkm232Handler(servo, self._usbkm232)
256 else:
Tom Wai-Hong Tamd64164c2015-04-29 07:59:45 +0800257 # The following boards don't use Chrome EC.
258 if board in ('alex', 'butterfly', 'lumpy', 'zgb'):
259 return keyboard_handlers.MatrixKeyboardHandler(servo)
260 return keyboard_handlers.ChromeECHandler(servo)
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -0800261
Ruben Rodriguez Buchillona16374b2018-06-20 16:45:00 -0700262 def close(self):
263 """Servod turn down logic."""
264 for i, interface in enumerate(self._interface_list):
265 self._logger.info('Turning down interface %d' % i)
266 if hasattr(interface, 'close'):
267 interface.close()
Todd Broch3ec8df02012-11-20 10:53:03 -0800268
Kevin Chengdc3befd2016-07-15 12:34:00 -0700269 def _init_ftdi_dummy(self, vendor, product, serialname, interface):
Kevin Cheng042f4932016-07-19 10:46:00 -0700270 """Dummy interface for ftdi devices.
271
272 This is a dummy function specifically for ftdi devices to not initialize
273 anything but to help pad the interface list.
274
275 Returns:
276 None.
277 """
278 return None
279
Kevin Chengdc3befd2016-07-15 12:34:00 -0700280 def _init_ftdi_gpio(self, vendor, product, serialname, interface):
Todd Broche505b8d2011-03-21 18:19:54 -0700281 """Initialize gpio driver interface and open for use.
282
283 Args:
284 interface: interface number of FTDI device to use.
285
286 Returns:
287 Instance object of interface.
Todd Broch6de9dc62012-04-09 15:23:53 -0700288
289 Raises:
290 ServodError: If init fails
Todd Broche505b8d2011-03-21 18:19:54 -0700291 """
Kevin Chengdc3befd2016-07-15 12:34:00 -0700292 fobj = ftdigpio.Fgpio(vendor, product, interface, serialname)
Todd Broch6de9dc62012-04-09 15:23:53 -0700293 try:
294 fobj.open()
295 except ftdigpio.FgpioError as e:
296 raise ServodError('Opening gpio interface. %s ( %d )' % (e.msg, e.value))
297
Todd Broche505b8d2011-03-21 18:19:54 -0700298 return fobj
299
Kevin Chengdc3befd2016-07-15 12:34:00 -0700300 def _init_stm32_uart(self, vendor, product, serialname, interface):
Nick Sanders97bc4462016-01-04 15:37:31 -0800301 """Initialize stm32 uart interface and open for use
302
303 Note, the uart runs in a separate thread. Users wishing to
304 interact with it will query control for the pty's pathname and connect
305 with their favorite console program. For example:
306 cu -l /dev/pts/22
307
308 Args:
309 interface: dict of interface parameters.
310
311 Returns:
312 Instance object of interface
313
314 Raises:
315 ServodError: Raised on init failure.
316 """
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700317 self._logger.info('Suart: interface: %s' % interface)
318 sobj = stm32uart.Suart(vendor, product, interface['interface'], serialname)
Nick Sanders97bc4462016-01-04 15:37:31 -0800319
320 try:
321 sobj.run()
322 except stm32uart.SuartError as e:
323 raise ServodError('Running uart interface. %s ( %d )' % (e.msg, e.value))
324
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700325 self._logger.info('%s' % sobj.get_pty())
Nick Sanders97bc4462016-01-04 15:37:31 -0800326 return sobj
327
Kevin Chengdc3befd2016-07-15 12:34:00 -0700328 def _init_stm32_gpio(self, vendor, product, serialname, interface):
Nick Sanders97bc4462016-01-04 15:37:31 -0800329 """Initialize stm32 gpio interface.
330 Args:
Wai-Hong Tam564c1702017-04-24 09:23:38 -0700331 interface: dict of interface parameters.
Nick Sanders97bc4462016-01-04 15:37:31 -0800332
333 Returns:
334 Instance object of interface
335
336 Raises:
337 SgpioError: Raised on init failure.
338 """
Kevin Cheng71a046f2016-06-13 16:37:58 -0700339 interface_number = interface
340 # Interface could be a dict.
341 if type(interface) is dict:
342 interface_number = interface['interface']
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700343 self._logger.info('Sgpio: interface: %s' % interface_number)
Kevin Chengdc3befd2016-07-15 12:34:00 -0700344 return stm32gpio.Sgpio(vendor, product, interface_number, serialname)
Nick Sanders97bc4462016-01-04 15:37:31 -0800345
Kevin Chengdc3befd2016-07-15 12:34:00 -0700346 def _init_stm32_i2c(self, vendor, product, serialname, interface):
Nick Sanders97bc4462016-01-04 15:37:31 -0800347 """Initialize stm32 USB to I2C bridge interface and open for use
348
349 Args:
Wai-Hong Tam564c1702017-04-24 09:23:38 -0700350 interface: dict of interface parameters.
Nick Sanders97bc4462016-01-04 15:37:31 -0800351
352 Returns:
353 Instance object of interface.
354
355 Raises:
356 Si2cError: Raised on init failure.
357 """
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700358 self._logger.info('Si2cBus: interface: %s' % interface)
Nick Sandersa3649712016-03-01 16:53:52 -0800359 port = interface.get('port', 0)
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700360 return stm32i2c.Si2cBus(vendor, product, interface['interface'], port=port,
361 serialname=serialname)
Nick Sanders97bc4462016-01-04 15:37:31 -0800362
Kevin Chengdc3befd2016-07-15 12:34:00 -0700363 def _init_bb_adc(self, vendor, product, serialname, interface):
Aaron.Chuang88eff332014-07-31 08:32:00 +0800364 """Initalize beaglebone ADC interface."""
365 return bbadc.BBadc()
366
Kevin Chengdc3befd2016-07-15 12:34:00 -0700367 def _init_bb_gpio(self, vendor, product, serialname, interface):
Simran Basie750a342013-03-12 13:45:26 -0700368 """Initalize beaglebone gpio interface."""
Simran Basi5492bde2013-05-16 17:08:47 -0700369 return bbgpio.BBgpio()
Simran Basie750a342013-03-12 13:45:26 -0700370
Kevin Chengdc3befd2016-07-15 12:34:00 -0700371 def _init_ftdi_i2c(self, vendor, product, serialname, interface):
Todd Broche505b8d2011-03-21 18:19:54 -0700372 """Initialize i2c interface and open for use.
373
374 Args:
375 interface: interface number of FTDI device to use
376
377 Returns:
378 Instance object of interface
Todd Broch6de9dc62012-04-09 15:23:53 -0700379
380 Raises:
381 ServodError: If init fails
Todd Broche505b8d2011-03-21 18:19:54 -0700382 """
Kevin Chengdc3befd2016-07-15 12:34:00 -0700383 fobj = ftdii2c.Fi2c(vendor, product, interface, serialname)
Todd Broch6de9dc62012-04-09 15:23:53 -0700384 try:
385 fobj.open()
386 except ftdii2c.Fi2cError as e:
387 raise ServodError('Opening i2c interface. %s ( %d )' % (e.msg, e.value))
388
Todd Broche505b8d2011-03-21 18:19:54 -0700389 # Set the frequency of operation of the i2c bus.
390 # TODO(tbroch) make configureable
391 fobj.setclock(MAX_I2C_CLOCK_HZ)
Todd Broch6de9dc62012-04-09 15:23:53 -0700392
Todd Broche505b8d2011-03-21 18:19:54 -0700393 return fobj
394
Simran Basie750a342013-03-12 13:45:26 -0700395 # TODO (sbasi) crbug.com/187489 - Implement bb_i2c.
396 def _init_bb_i2c(self, interface):
397 """Initalize beaglebone i2c interface."""
Simran Basia9ad25e2013-04-23 11:57:00 -0700398 return bbi2c.BBi2c(interface)
Simran Basie750a342013-03-12 13:45:26 -0700399
Kevin Chengdc3befd2016-07-15 12:34:00 -0700400 def _init_dev_i2c(self, vendor, product, serialname, interface):
Rong Changc6c8c022014-08-11 14:07:11 +0800401 """Initalize Linux i2c-dev interface."""
402 return i2cbus.I2CBus('/dev/i2c-%d' % interface['bus_num'])
403
Kevin Chengdc3befd2016-07-15 12:34:00 -0700404 def _init_ftdi_uart(self, vendor, product, serialname, interface):
Simran Basie750a342013-03-12 13:45:26 -0700405 """Initialize ftdi uart inteface and open for use
Todd Broch47c43f42011-05-26 15:11:31 -0700406
407 Note, the uart runs in a separate thread (pthreads). Users wishing to
408 interact with it will query control for the pty's pathname and connect
409 with there favorite console program. For example:
410 cu -l /dev/pts/22
411
412 Args:
413 interface: interface number of FTDI device to use
414
415 Returns:
416 Instance object of interface
Todd Broch6de9dc62012-04-09 15:23:53 -0700417
418 Raises:
419 ServodError: If init fails
Todd Broch47c43f42011-05-26 15:11:31 -0700420 """
Kevin Chengdc3befd2016-07-15 12:34:00 -0700421 fobj = ftdiuart.Fuart(vendor, product, interface, serialname)
Todd Broch6de9dc62012-04-09 15:23:53 -0700422 try:
423 fobj.run()
424 except ftdiuart.FuartError as e:
425 raise ServodError('Running uart interface. %s ( %d )' % (e.msg, e.value))
426
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700427 self._logger.info('%s' % fobj.get_pty())
Todd Broch47c43f42011-05-26 15:11:31 -0700428 return fobj
429
Simran Basie750a342013-03-12 13:45:26 -0700430 # TODO (sbasi) crbug.com/187492 - Implement bbuart.
Kevin Chengdc3befd2016-07-15 12:34:00 -0700431 def _init_bb_uart(self, vendor, product, serialname, interface):
Simran Basie750a342013-03-12 13:45:26 -0700432 """Initalize beaglebone uart interface."""
Simran Basi949309b2013-05-31 15:12:15 -0700433 logging.debug('UART INTERFACE: %s', interface)
434 return bbuart.BBuart(interface)
Simran Basie750a342013-03-12 13:45:26 -0700435
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700436 def _init_ftdi_gpiouart(self, vendor, product, serialname, interface):
Todd Broch888da782011-10-07 14:29:09 -0700437 """Initialize special gpio + uart interface and open for use
438
439 Note, the uart runs in a separate thread (pthreads). Users wishing to
440 interact with it will query control for the pty's pathname and connect
441 with there favorite console program. For example:
442 cu -l /dev/pts/22
443
444 Args:
445 interface: interface number of FTDI device to use
446
447 Returns:
448 Instance objects of interface
Todd Broch6de9dc62012-04-09 15:23:53 -0700449
450 Raises:
451 ServodError: If init fails
Todd Broch888da782011-10-07 14:29:09 -0700452 """
Kevin Chengce7dafd2016-08-02 11:11:38 -0700453 fgpio = self._init_ftdi_gpio(vendor, product, serialname, interface)
Kevin Chengdc3befd2016-07-15 12:34:00 -0700454 fuart = ftdiuart.Fuart(vendor, product, interface, serialname, fgpio._fc)
Todd Broch6de9dc62012-04-09 15:23:53 -0700455 try:
456 fuart.run()
457 except ftdiuart.FuartError as e:
458 raise ServodError('Running uart interface. %s ( %d )' % (e.msg, e.value))
459
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700460 self._logger.info('uart pty: %s' % fuart.get_pty())
Todd Broch888da782011-10-07 14:29:09 -0700461 return fgpio, fuart
462
Kevin Chengdc3befd2016-07-15 12:34:00 -0700463 def _init_ec3po_uart(self, vendor, product, serialname, interface):
Aseda Aboagyea4922212015-11-20 15:19:08 -0800464 """Initialize EC-3PO console interpreter interface.
465
466 Args:
467 interface: A dictionary representing the interface.
468
469 Returns:
470 An EC3PO object representing the EC-3PO interface or None if there's no
471 interface for the USB PD UART.
472 """
Wai-Hong Tam6c0fa592017-04-21 12:41:33 -0700473 raw_uart_name = interface['raw_pty']
Nick Sanders116ed9e2018-03-09 19:05:16 -0800474 raw_uart_source = interface['source']
Wai-Hong Tam6c0fa592017-04-21 12:41:33 -0700475 if self._syscfg.is_control(raw_uart_name):
Nick Sanders97bc4462016-01-04 15:37:31 -0800476 raw_ec_uart = self.get(raw_uart_name)
Nick Sanders116ed9e2018-03-09 19:05:16 -0800477 return ec3po_interface.EC3PO(raw_ec_uart, raw_uart_source)
Aseda Aboagyea4922212015-11-20 15:19:08 -0800478 else:
Wai-Hong Tam6c0fa592017-04-21 12:41:33 -0700479 # The overlay doesn't have the raw PTY defined, therefore we can skip
480 # initializing this interface since no control relies on it.
481 self._logger.debug(
482 'Skip initializing EC3PO for %s, no control specified.',
483 raw_uart_name)
484 return None
Aseda Aboagyea4922212015-11-20 15:19:08 -0800485
Tom Wai-Hong Tam28f0a5f2012-08-21 12:49:57 +0800486 def _camel_case(self, string):
487 output = ''
488 for s in string.split('_'):
489 if output:
490 output += s.capitalize()
491 else:
492 output = s
493 return output
494
Wai-Hong Tam4544c302017-05-24 19:44:53 -0700495 def clear_cached_drv(self):
496 """Clear the cached drivers.
497
498 The drivers are cached in the Dict _drv_dict when a control is got or set.
499 When the servo interfaces are relocated, the cached values may become wrong.
500 Should call this method to clear the cached values.
501 """
502 self._drv_dict = {}
503
Ruben Rodriguez Buchillon2c6589f2018-10-20 15:30:26 +0800504 def _get_servo_specific_param(self, params, param_key, control_name):
505 """Get |param_key| from params by looking for servo specific params first.
506
507 Find the candidate servos. Using servo_v4 with a servo_micro connected as
508 example, the following shows the priority for selecting the interface.
509
510 1. The full name. (e.g. - 'servo_v4_with_servo_micro_interface')
511 2. servo_micro_interface
512 3. servo_v4_interface
513 4. Fallback to the default, interface.
514
515 Args:
516 params: params dictionary for a control
517 param_key: identifier in the params dictionary to look for
518 control_name: control name the params correspond to
519
520 Returns:
521 The best suited param value for param_key given the servo type or
522 None if even the default is not defined.
523 """
524 candidates = [self._version]
525 candidates.extend(reversed(self._version.split('_with_')))
526 candidates = ['%s_%s' % (c, param_key) for c in candidates]
527 candidates.append(param_key)
528 for c in candidates:
529 if c in params:
530 self._logger.debug('Using %s parameter.', c)
531 return params[c]
532 self._logger.error('Unable to determine %s for %s', param_key, control_name)
533 self._logger.error('params: %r', params)
534 return None
535
Todd Broche505b8d2011-03-21 18:19:54 -0700536 def _get_param_drv(self, control_name, is_get=True):
537 """Get access to driver for a given control.
538
539 Note, some controls have different parameter dictionaries for 'getting' the
540 control's value versus 'setting' it. Boolean is_get distinguishes which is
541 being requested.
542
543 Args:
544 control_name: string name of control
545 is_get: boolean to determine
546
547 Returns:
548 tuple (param, drv) where:
549 param: param dictionary for control
550 drv: instance object of driver for particular control
551
552 Raises:
553 ServodError: Error occurred while examining params dict
554 """
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700555 self._logger.debug('')
Todd Broche505b8d2011-03-21 18:19:54 -0700556 # if already setup just return tuple from driver dict
557 if control_name in self._drv_dict:
558 if is_get and ('get' in self._drv_dict[control_name]):
559 return self._drv_dict[control_name]['get']
560 if not is_get and ('set' in self._drv_dict[control_name]):
561 return self._drv_dict[control_name]['set']
562
563 params = self._syscfg.lookup_control_params(control_name, is_get)
Simran Basi668be0e2013-08-07 11:54:50 -0700564
Ruben Rodriguez Buchillon2c6589f2018-10-20 15:30:26 +0800565 # Get the most suitable drv given the servo instance.
566 drv_name = self._get_servo_specific_param(params, 'drv', control_name)
567 if drv_name == 'na':
568 # 'na' drv can be used to selectively turn controls into noops for
569 # a given servo hardware. Ensure that there is an interface.
570 params.setdefault('interface', 'servo')
571 self._logger.debug('Setting interface to default to %r for %r unless '
572 ' defined in params, as drv is %r.', 'servo',
573 control_name, 'na')
574 # Setting input_type to str allows all inputs through enabling a true noop
575 params.update({'input_type': 'str'})
576 interface_id = self._get_servo_specific_param(params, 'interface',
577 control_name)
578 if None in [drv_name, interface_id]:
579 raise ServodError('No drv/interface for control %r found' % control_name)
Aseda Aboagye1d8477b2017-05-10 17:24:31 -0700580
J. Richard Barnette275d9fd2014-02-11 14:38:54 -0800581 if interface_id == 'servo':
582 interface = self
Simran Basi668be0e2013-08-07 11:54:50 -0700583 else:
Wai-Hong Tam564c1702017-04-24 09:23:38 -0700584 index = int(interface_id)
J. Richard Barnette275d9fd2014-02-11 14:38:54 -0800585 interface = self._interface_list[index]
Simran Basi668be0e2013-08-07 11:54:50 -0700586
Wai-Hong Tam4c09eff2017-02-17 11:46:19 -0800587 drv_module = getattr(servo_drv, drv_name)
Tom Wai-Hong Tam28f0a5f2012-08-21 12:49:57 +0800588 drv_class = getattr(drv_module, self._camel_case(drv_name))
Todd Broche505b8d2011-03-21 18:19:54 -0700589 drv = drv_class(interface, params)
590 if control_name not in self._drv_dict:
591 self._drv_dict[control_name] = {}
592 if is_get:
593 self._drv_dict[control_name]['get'] = (params, drv)
594 else:
595 self._drv_dict[control_name]['set'] = (params, drv)
596 return (params, drv)
597
598 def doc_all(self):
599 """Return all documenation for controls.
600
601 Returns:
602 string of <doc> text in config file (xml) and the params dictionary for
603 all controls.
604
605 For example:
606 warm_reset :: Reset the device warmly
607 ------------------------> {'interface': '1', 'map': 'onoff_i', ... }
608 """
609 return self._syscfg.display_config()
610
611 def doc(self, name):
612 """Retreive doc string in system config file for given control name.
613
614 Args:
615 name: name string of control to get doc string
616
617 Returns:
618 doc string of name
619
620 Raises:
621 NameError: if fails to locate control
622 """
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700623 self._logger.debug('name(%s)' % (name))
Todd Broche505b8d2011-03-21 18:19:54 -0700624 if self._syscfg.is_control(name):
625 return self._syscfg.get_control_docstring(name)
626 else:
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700627 raise NameError('No control %s' % name)
Todd Broche505b8d2011-03-21 18:19:54 -0700628
Ruben Rodriguez Buchillon247d88f2018-08-03 18:07:01 +0800629 def safe_switch_usbkey_power(self, power_state, _=None):
Kevin Cheng5595b342016-09-29 15:51:01 -0700630 """Toggle the usb power safely.
631
Kevin Chengc49494e2016-07-25 12:13:38 -0700632 Args:
Kevin Cheng5595b342016-09-29 15:51:01 -0700633 power_state: The setting to set for the usbkey power.
Ruben Rodriguez Buchillon247d88f2018-08-03 18:07:01 +0800634 _: to conform to current API
Kevin Chengc49494e2016-07-25 12:13:38 -0700635
Kevin Cheng5595b342016-09-29 15:51:01 -0700636 Returns:
637 An empty string to appease the xmlrpc gods.
638 """
Ruben Rodriguez Buchillon247d88f2018-08-03 18:07:01 +0800639 self.set('image_usbkey_pwr', power_state)
Kevin Cheng5595b342016-09-29 15:51:01 -0700640 return ''
641
Ruben Rodriguez Buchillon247d88f2018-08-03 18:07:01 +0800642 def safe_switch_usbkey(self, mux_direction, _=0):
Kevin Cheng5595b342016-09-29 15:51:01 -0700643 """Toggle the usb direction safely.
644
Kevin Cheng5595b342016-09-29 15:51:01 -0700645 Args:
Wai-Hong Tamf93f9a22018-02-06 14:24:46 -0800646 mux_direction: "servo_sees_usbkey" or "dut_sees_usbkey".
Ruben Rodriguez Buchillon247d88f2018-08-03 18:07:01 +0800647 _: to conform to current API
Kevin Cheng5595b342016-09-29 15:51:01 -0700648
649 Returns:
650 An empty string to appease the xmlrpc gods.
651 """
Ruben Rodriguez Buchillon247d88f2018-08-03 18:07:01 +0800652 self.set('image_usbkey_direction', mux_direction)
Kevin Cheng5595b342016-09-29 15:51:01 -0700653 return ''
654
Ruben Rodriguez Buchillon68958f82018-08-03 18:24:28 +0800655 def probe_host_usb_dev(self, _=0):
Simran Basia9f41032012-05-11 14:21:58 -0700656 """Probe the USB disk device plugged in the servo from the host side.
657
Kevin Cheng5595b342016-09-29 15:51:01 -0700658 Args:
Ruben Rodriguez Buchillon68958f82018-08-03 18:24:28 +0800659 _: to conform to current API
Kevin Cheng5595b342016-09-29 15:51:01 -0700660
Simran Basia9f41032012-05-11 14:21:58 -0700661 Returns:
Kevin Chengc49494e2016-07-25 12:13:38 -0700662 USB disk path if one and only one USB disk path is found, otherwise an
Simran Basia9f41032012-05-11 14:21:58 -0700663 """
Ruben Rodriguez Buchillon68958f82018-08-03 18:24:28 +0800664 return self.get('image_usbkey_dev')
Kevin Chengc49494e2016-07-25 12:13:38 -0700665
Ruben Rodriguez Buchillon68958f82018-08-03 18:24:28 +0800666 def download_image_to_usb(self, image_path, _=0):
Simran Basia9f41032012-05-11 14:21:58 -0700667 """Download image and save to the USB device found by probe_host_usb_dev.
668 If the image_path is a URL, it will download this url to the USB path;
669 otherwise it will simply copy the image_path's contents to the USB path.
670
671 Args:
672 image_path: path or url to the recovery image.
Ruben Rodriguez Buchillon68958f82018-08-03 18:24:28 +0800673 _: to conform to current API
Simran Basia9f41032012-05-11 14:21:58 -0700674
675 Returns:
676 True|False: True if process completed successfully, False if error
Ruben Rodriguez Buchillon4e00f0e2018-08-28 15:21:47 +0800677 occurred.
Simran Basia9f41032012-05-11 14:21:58 -0700678 """
Simran Basia9f41032012-05-11 14:21:58 -0700679 try:
Ruben Rodriguez Buchillon4e00f0e2018-08-28 15:21:47 +0800680 self.set('download_image_to_usb_dev', image_path)
681 return True
682 except Exception:
Simran Basia9f41032012-05-11 14:21:58 -0700683 return False
Simran Basia9f41032012-05-11 14:21:58 -0700684
685 def make_image_noninteractive(self):
686 """Makes the recovery image noninteractive.
687
688 A noninteractive image will reboot automatically after installation
689 instead of waiting for the USB device to be removed to initiate a system
690 reboot.
691
692 Mounts partition 1 of the image stored on usb_dev and creates a file
693 called "non_interactive" so that the image will become noninteractive.
694
695 Returns:
696 True|False: True if process completed successfully, False if error
Ruben Rodriguez Buchillon1a3a7ec2018-08-03 18:44:55 +0800697 occurred.
Simran Basia9f41032012-05-11 14:21:58 -0700698 """
Ruben Rodriguez Buchillon1a3a7ec2018-08-03 18:44:55 +0800699 try:
700 usb_dev = self.get('image_usbkey_dev')
701 usb_dev_partition = '%s1' % usb_dev
702 self.set('make_usb_dev_image_noninteractive', usb_dev_partition)
703 return True
704 except Exception:
Simran Basia9f41032012-05-11 14:21:58 -0700705 return False
Simran Basia9f41032012-05-11 14:21:58 -0700706
Todd Broch352b4b22013-03-22 09:48:40 -0700707 def set_get_all(self, cmds):
708 """Set &| get one or more control values.
709
710 Args:
711 cmds: list of control[:value] to get or set.
712
713 Returns:
714 rv: list of responses from calling get or set methods.
715 """
716 rv = []
717 for cmd in cmds:
718 if ':' in cmd:
719 (control, value) = cmd.split(':')
720 rv.append(self.set(control, value))
721 else:
722 rv.append(self.get(cmd))
723 return rv
724
Aseda Aboagye6921f602017-08-01 14:45:38 -0700725 def get_serial_number(self, name):
726 """Returns the desired serial number from the serialnames dict.
727
728 Args:
729 name: A string which is the key into the _serialnames dictionary.
730
731 Returns:
732 A string containing the serial number or "unknown".
733 """
734 if not name:
735 name = 'main'
736
737 try:
738 return self._serialnames[name]
739 except KeyError:
740 self._logger.debug("'%s_serialname' not found!", name)
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700741 return 'unknown'
Aseda Aboagye6921f602017-08-01 14:45:38 -0700742
Todd Broche505b8d2011-03-21 18:19:54 -0700743 def get(self, name):
744 """Get control value.
745
746 Args:
747 name: name string of control
748
749 Returns:
750 Response from calling drv get method. Value is reformatted based on
751 control's dictionary parameters
752
753 Raises:
754 HwDriverError: Error occurred while using drv
Ruben Rodriguez Buchillona5d8b922018-09-03 16:51:03 +0800755 ServodError: if interfaces are not available within timeout period
Todd Broche505b8d2011-03-21 18:19:54 -0700756 """
Ruben Rodriguez Buchillona5d8b922018-09-03 16:51:03 +0800757 if not self._ifaces_available.wait(self.INTERFACE_AVAILABILITY_TIMEOUT):
758 raise ServodError('Timed out waiting for interfaces to become available.')
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700759 self._logger.debug('name(%s)' % (name))
Wai-Hong Tambafeca72017-10-05 14:22:12 -0700760 # This route is to retrieve serialnames on servo v4, which
761 # connects to multiple servo-micros or CCD, like the controls,
762 # 'ccd_serialname', 'servo_micro_for_soraka_serialname', etc.
763 # TODO(aaboagye): Refactor it.
764 if 'serialname' in name:
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700765 return self.get_serial_number(name.split('serialname')[0].strip('_'))
Wai-Hong Tambafeca72017-10-05 14:22:12 -0700766
Todd Broche505b8d2011-03-21 18:19:54 -0700767 (param, drv) = self._get_param_drv(name)
768 try:
769 val = drv.get()
770 rd_val = self._syscfg.reformat_val(param, val)
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700771 self._logger.debug('%s = %s' % (name, rd_val))
Todd Broche505b8d2011-03-21 18:19:54 -0700772 return rd_val
Todd Brochfbc499d2011-06-16 16:09:58 -0700773 except AttributeError, error:
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700774 self._logger.error('Getting %s: %s' % (name, error))
Todd Brochfbc499d2011-06-16 16:09:58 -0700775 raise
Vic Yangbe6cf262012-09-10 10:40:56 +0800776 except HwDriverError:
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700777 self._logger.error('Getting %s' % (name))
Todd Broche505b8d2011-03-21 18:19:54 -0700778 raise
Todd Brochd6061672012-05-11 15:52:47 -0700779
Todd Broche505b8d2011-03-21 18:19:54 -0700780 def get_all(self, verbose):
781 """Get all controls values.
782
783 Args:
784 verbose: Boolean on whether to return doc info as well
785
786 Returns:
787 string creating from trying to get all values of all controls. In case of
788 error attempting access to control, response is 'ERR'.
789 """
Vadim Bendeburyb07944c2013-01-16 10:47:10 -0800790 rsp = []
Todd Broche505b8d2011-03-21 18:19:54 -0700791 for name in self._syscfg.syscfg_dict['control']:
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700792 self._logger.debug('name = %s' % name)
Todd Broche505b8d2011-03-21 18:19:54 -0700793 try:
794 value = self.get(name)
795 except Exception:
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700796 value = 'ERR'
Todd Broche505b8d2011-03-21 18:19:54 -0700797 pass
798 if verbose:
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700799 rsp.append('GET %s = %s :: %s' % (name, value, self.doc(name)))
Todd Broche505b8d2011-03-21 18:19:54 -0700800 else:
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700801 rsp.append('%s:%s' % (name, value))
Vadim Bendeburyb07944c2013-01-16 10:47:10 -0800802 return '\n'.join(sorted(rsp))
Todd Broche505b8d2011-03-21 18:19:54 -0700803
804 def set(self, name, wr_val_str):
805 """Set control.
806
807 Args:
808 name: name string of control
809 wr_val_str: value string to write. Can be integer, float or a
810 alpha-numerical that is mapped to a integer or float.
811
812 Raises:
813 HwDriverError: Error occurred while using driver
Ruben Rodriguez Buchillona5d8b922018-09-03 16:51:03 +0800814 ServodError: if interfaces are not available within timeout period
Todd Broche505b8d2011-03-21 18:19:54 -0700815 """
Ruben Rodriguez Buchillona5d8b922018-09-03 16:51:03 +0800816 if not self._ifaces_available.wait(self.INTERFACE_AVAILABILITY_TIMEOUT):
817 raise ServodError('Timed out waiting for interfaces to become available.')
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700818 self._logger.debug('name(%s) wr_val(%s)' % (name, wr_val_str))
Todd Broche505b8d2011-03-21 18:19:54 -0700819 (params, drv) = self._get_param_drv(name, False)
820 wr_val = self._syscfg.resolve_val(params, wr_val_str)
821 try:
822 drv.set(wr_val)
Vic Yangbe6cf262012-09-10 10:40:56 +0800823 except HwDriverError:
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700824 self._logger.error('Setting %s -> %s' % (name, wr_val_str))
Todd Broche505b8d2011-03-21 18:19:54 -0700825 raise
Ruben Rodriguez Buchillonb5fe0f12018-05-09 10:19:56 +0800826 # TODO(crbug.com/841097) Figure out why despite allow_none=True for both
827 # xmlrpc server & client I still have to return something to appease the
Todd Broche505b8d2011-03-21 18:19:54 -0700828 # marshall/unmarshall
829 return True
830
Todd Brochd6061672012-05-11 15:52:47 -0700831 def hwinit(self, verbose=False):
832 """Initialize all controls.
833
834 These values are part of the system config XML files of the form
835 init=<value>. This command should be used by clients wishing to return the
836 servo and DUT its connected to a known good/safe state.
837
Vadim Bendeburybb51dd42013-01-31 13:47:46 -0800838 Note that initialization errors are ignored (as in some cases they could
839 be caused by DUT firmware deficiencies). This might need to be fine tuned
840 later.
841
Todd Brochd6061672012-05-11 15:52:47 -0700842 Args:
843 verbose: boolean, if True prints info about control initialized.
844 Otherwise prints nothing.
Vadim Bendebury5934e4b2013-02-06 13:57:54 -0800845
846 Returns:
847 This function is called across RPC and as such is expected to return
848 something unless transferring 'none' across is allowed. Hence adding a
849 dummy return value to make things simpler.
Todd Brochd6061672012-05-11 15:52:47 -0700850 """
Todd Brochd9acf0a2012-12-05 13:43:06 -0800851 for control_name, value in self._syscfg.hwinit:
Todd Broch3ec8df02012-11-20 10:53:03 -0800852 try:
John Carey6fe2bbf2015-08-31 16:13:03 -0700853 # Workaround for bug chrome-os-partner:42349. Without this check, the
854 # gpio will briefly pulse low if we set it from high to high.
855 if self.get(control_name) != value:
Aseda Aboagyea849d462016-05-04 17:08:16 -0700856 self.set(control_name, value)
857 if verbose:
858 self._logger.info('Initialized %s to %s', control_name, value)
Matthew Bleckera5d979c2018-10-16 20:59:19 -0700859 except Exception:
860 self._logger.exception(
861 'Problem initializing %s -> %s', control_name, value)
Nick Sandersbc836282015-12-08 21:19:23 -0800862
863 # Init keyboard after all the intefaces are up.
864 self._keyboard = self._init_keyboard_handler(self, self._board)
Vadim Bendebury5934e4b2013-02-06 13:57:54 -0800865 return True
Todd Broch3ec8df02012-11-20 10:53:03 -0800866
Todd Broche505b8d2011-03-21 18:19:54 -0700867 def echo(self, echo):
868 """Dummy echo function for testing/examples.
869
870 Args:
871 echo: string to echo back to client
872 """
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700873 self._logger.debug('echo(%s)' % (echo))
874 return 'ECH0ING: %s' % (echo)
Todd Broche505b8d2011-03-21 18:19:54 -0700875
J. Richard Barnettee2820552013-03-14 16:13:46 -0700876 def get_board(self):
877 """Return the board specified at startup, if any."""
878 return self._board
879
Wai-Hong Tam416cf612017-09-19 11:39:21 -0700880 def get_base_board(self):
881 """Returns the board name of the base if present.
882
883 Returns:
884 A string of the board name, or '' if not present.
885 """
886 # The value is set in servo_postinit.
887 return self._base_board
888
Simran Basia23c1392013-08-06 14:59:10 -0700889 def get_version(self):
890 """Get servo board version."""
891 return self._version
892
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -0800893 def power_long_press(self):
894 """Simulate a long power button press."""
895 # After a long power press, the EC may ignore the next power
896 # button press (at least on Alex). To guarantee that this
897 # won't happen, we need to allow the EC one second to
898 # collect itself.
Ruben Rodriguez Buchillon0f467942018-07-27 18:02:32 +0800899 return self.set('power_key', 'long_press')
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -0800900
901 def power_normal_press(self):
902 """Simulate a normal power button press."""
Ruben Rodriguez Buchillon0f467942018-07-27 18:02:32 +0800903 return self.set('power_key', 'press')
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -0800904
905 def power_short_press(self):
906 """Simulate a short power button press."""
Lenine Ajagappane400d7d22018-09-05 02:29:21 +0530907 return self.set('power_key', 'short_press')
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -0800908
Lenine Ajagappane400d7d22018-09-05 02:29:21 +0530909 def power_key(self, press_secs=''):
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -0800910 """Simulate a power button press.
911
912 Args:
Lenine Ajagappane400d7d22018-09-05 02:29:21 +0530913 press_secs: Time in seconds to simulate the keypress.
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -0800914 """
Lenine Ajagappane400d7d22018-09-05 02:29:21 +0530915 return self.set('power_key', 'press' if press_secs is '' else press_secs)
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -0800916
917 def ctrl_d(self, press_secs=''):
918 """Simulate Ctrl-d simultaneous button presses."""
Lenine Ajagappane400d7d22018-09-05 02:29:21 +0530919 return self.set('ctrl_d', 'tab' if press_secs is '' else press_secs)
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -0800920
Victor Dodone539cea2016-03-29 18:50:17 -0700921 def ctrl_u(self, press_secs=''):
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -0800922 """Simulate Ctrl-u simultaneous button presses."""
Lenine Ajagappane400d7d22018-09-05 02:29:21 +0530923 return self.set('ctrl_u', 'tab' if press_secs is '' else press_secs)
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -0800924
925 def ctrl_enter(self, press_secs=''):
926 """Simulate Ctrl-enter simultaneous button presses."""
Lenine Ajagappane400d7d22018-09-05 02:29:21 +0530927 return self.set('ctrl_enter', 'tab' if press_secs is '' else press_secs)
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -0800928
929 def d_key(self, press_secs=''):
930 """Simulate Enter key button press."""
Lenine Ajagappane400d7d22018-09-05 02:29:21 +0530931 return self.set('d_key', 'tab' if press_secs is '' else press_secs)
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -0800932
933 def ctrl_key(self, press_secs=''):
934 """Simulate Enter key button press."""
Lenine Ajagappane400d7d22018-09-05 02:29:21 +0530935 return self.set('ctrl_key', 'tab' if press_secs is '' else press_secs)
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -0800936
937 def enter_key(self, press_secs=''):
938 """Simulate Enter key button press."""
Lenine Ajagappane400d7d22018-09-05 02:29:21 +0530939 return self.set('enter_key', 'tab' if press_secs is '' else press_secs)
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -0800940
941 def refresh_key(self, press_secs=''):
942 """Simulate Refresh key (F3) button press."""
Lenine Ajagappane400d7d22018-09-05 02:29:21 +0530943 return self.set('refresh_key', 'tab' if press_secs is '' else press_secs)
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -0800944
945 def ctrl_refresh_key(self, press_secs=''):
946 """Simulate Ctrl and Refresh (F3) simultaneous press.
947
948 This key combination is an alternative of Space key.
949 """
Lenine Ajagappane400d7d22018-09-05 02:29:21 +0530950 return self.set('ctrl_refresh_key', ('tab' if press_secs is '' else
951 press_secs))
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -0800952
953 def imaginary_key(self, press_secs=''):
954 """Simulate imaginary key button press.
955
956 Maps to a key that doesn't physically exist.
957 """
Lenine Ajagappane400d7d22018-09-05 02:29:21 +0530958 return self.set('imaginary_key', 'tab' if press_secs is '' else press_secs)
Yusuf Mohsinally29e30d22014-01-14 15:29:17 -0800959
Vincent Palatin3acbbe52016-07-19 17:40:12 +0200960 def sysrq_x(self, press_secs=''):
961 """Simulate Alt VolumeUp X simultaneous press.
962
963 This key combination is the kernel system request (sysrq) x.
964 """
Lenine Ajagappane400d7d22018-09-05 02:29:21 +0530965 return self.set('sysrq_x', 'tab' if press_secs is '' else press_secs)
Vincent Palatin3acbbe52016-07-19 17:40:12 +0200966
Kevin Cheng4b4f0022016-09-09 02:37:07 -0700967 def get_servo_serials(self):
968 """Return all the serials associated with this process."""
969 return self._serialnames
970
971
Todd Broche505b8d2011-03-21 18:19:54 -0700972def test():
973 """Integration testing.
974
975 TODO(tbroch) Enhance integration test and add unittest (see mox)
976 """
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700977 logging.basicConfig(
978 level=logging.DEBUG,
979 format='%(asctime)s - %(name)s - ' + '%(levelname)s - %(message)s')
Todd Broche505b8d2011-03-21 18:19:54 -0700980 # configure server & listen
981 servod_obj = Servod(1)
Wai-Hong Tam564c1702017-04-24 09:23:38 -0700982 # 5 == number of interfaces on a FT4232H device
983 for i in xrange(1, 5):
984 if i == 2:
Todd Broche505b8d2011-03-21 18:19:54 -0700985 # its an i2c interface ... see __init__ for details and TODO to make
986 # this configureable
987 servod_obj._interface_list[i].wr_rd(0x21, [0], 1)
988 else:
989 # its a gpio interface
990 servod_obj._interface_list[i].wr_rd(0)
991
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700992 server = SimpleXMLRPCServer.SimpleXMLRPCServer(('localhost', 9999),
Todd Broche505b8d2011-03-21 18:19:54 -0700993 allow_none=True)
994 server.register_introspection_functions()
995 server.register_multicall_functions()
996 server.register_instance(servod_obj)
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -0700997 logging.info('Listening on localhost port 9999')
Todd Broche505b8d2011-03-21 18:19:54 -0700998 server.serve_forever()
999
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -07001000
1001if __name__ == '__main__':
Todd Broche505b8d2011-03-21 18:19:54 -07001002 test()
1003
1004 # simple client transaction would look like
Puthikorn Voravootivat01ead152018-03-23 15:38:40 -07001005 """remote_uri = 'http://localhost:9999' client = xmlrpclib.ServerProxy(remote_uri, verbose=False) send_str = "Hello_there" print "Sent " + send_str + ", Recv " + client.echo(send_str)
1006
Todd Broche505b8d2011-03-21 18:19:54 -07001007 """