# Lint as: python2, python3 # Copyright (c) 2012 The Chromium OS Authors. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. """Implement a modem proxy to talk to a ModemManager1 modem.""" from __future__ import absolute_import from __future__ import division from __future__ import print_function from autotest_lib.client.common_lib import error from autotest_lib.client.cros.cellular import cellular from autotest_lib.client.cros.cellular import cellular_logging from autotest_lib.client.cros.cellular import mm1 from autotest_lib.client.cros.cellular import mm1_constants import dbus import six log = cellular_logging.SetupCellularLogging('modem1') MODEM_TIMEOUT = 60 class Modem(object): """An object which talks to a ModemManager1 modem.""" # MM_MODEM_GSM_ACCESS_TECH (not exported) # From /usr/include/mm/mm-modem.h _MM_MODEM_GSM_ACCESS_TECH_UNKNOWN = 0 _MM_MODEM_GSM_ACCESS_TECH_GSM = 1 << 1 _MM_MODEM_GSM_ACCESS_TECH_GSM_COMPACT = 1 << 2 _MM_MODEM_GSM_ACCESS_TECH_GPRS = 1 << 3 _MM_MODEM_GSM_ACCESS_TECH_EDGE = 1 << 4 _MM_MODEM_GSM_ACCESS_TECH_UMTS = 1 << 5 _MM_MODEM_GSM_ACCESS_TECH_HSDPA = 1 << 6 _MM_MODEM_GSM_ACCESS_TECH_HSUPA = 1 << 7 _MM_MODEM_GSM_ACCESS_TECH_HSPA = 1 << 8 # Mapping of modem technologies to cellular technologies _ACCESS_TECH_TO_TECHNOLOGY = { _MM_MODEM_GSM_ACCESS_TECH_GSM: cellular.Technology.WCDMA, _MM_MODEM_GSM_ACCESS_TECH_GSM_COMPACT: cellular.Technology.WCDMA, _MM_MODEM_GSM_ACCESS_TECH_GPRS: cellular.Technology.GPRS, _MM_MODEM_GSM_ACCESS_TECH_EDGE: cellular.Technology.EGPRS, _MM_MODEM_GSM_ACCESS_TECH_UMTS: cellular.Technology.WCDMA, _MM_MODEM_GSM_ACCESS_TECH_HSDPA: cellular.Technology.HSDPA, _MM_MODEM_GSM_ACCESS_TECH_HSUPA: cellular.Technology.HSUPA, _MM_MODEM_GSM_ACCESS_TECH_HSPA: cellular.Technology.HSDUPA, } def __init__(self, manager, path): self.manager = manager self.bus = manager.bus self.service = manager.service self.path = path def Modem(self): obj = self.bus.get_object(self.service, self.path) return dbus.Interface(obj, mm1.MODEM_INTERFACE) def SimpleModem(self): obj = self.bus.get_object(self.service, self.path) return dbus.Interface(obj, mm1.MODEM_SIMPLE_INTERFACE) def GsmModem(self): obj = self.bus.get_object(self.service, self.path) return dbus.Interface(obj, mm1.MODEM_MODEM3GPP_INTERFACE) def CdmaModem(self): obj = self.bus.get_object(self.service, self.path) return dbus.Interface(obj, mm1.MODEM_MODEMCDMA_INTERFACE) def Sim(self): obj = self.bus.get_object(self.service, self.path) return dbus.Interface(obj, mm1.SIM_INTERFACE) def PropertiesInterface(self): obj = self.bus.get_object(self.service, self.path) return dbus.Interface(obj, dbus.PROPERTIES_IFACE) def GetAll(self, iface): obj_iface = self.PropertiesInterface() return obj_iface.GetAll(iface) def _GetModemInterfaces(self): return [ mm1.MODEM_INTERFACE, mm1.MODEM_SIMPLE_INTERFACE, mm1.MODEM_MODEM3GPP_INTERFACE, mm1.MODEM_MODEMCDMA_INTERFACE ] @staticmethod def _CopyPropertiesCheckUnique(src, dest): """Copies properties from |src| to |dest| and makes sure there are no duplicate properties that have different values.""" for key, value in six.iteritems(src): if key in dest and value != dest[key]: raise KeyError('Duplicate property %s, different values ' '("%s", "%s")' % (key, value, dest[key])) dest[key] = value def GetModemProperties(self): """Returns all DBus Properties of all the modem interfaces.""" props = dict() for iface in self._GetModemInterfaces(): try: iface_props = self.GetAll(iface) except dbus.exceptions.DBusException: continue if iface_props: self._CopyPropertiesCheckUnique(iface_props, props) try: sim_obj = self.bus.get_object(self.service, props['Sim']) sim_props_iface = dbus.Interface(sim_obj, dbus.PROPERTIES_IFACE) sim_props = sim_props_iface.GetAll(mm1.SIM_INTERFACE) # SIM cards may store an empty operator name or store a value # different from the one obtained OTA. Rename the 'OperatorName' # property obtained from the SIM card to 'SimOperatorName' in # order to avoid a potential conflict with the 'OperatorName' # property obtained from the Modem3gpp interface. if 'OperatorName' in sim_props: sim_props['SimOperatorName'] = sim_props.pop('OperatorName') self._CopyPropertiesCheckUnique(sim_props, props) except dbus.exceptions.DBusException: pass return props def GetAccessTechnology(self): """Returns the modem access technology.""" props = self.GetModemProperties() tech = props['AccessTechnologies'] return Modem._ACCESS_TECH_TO_TECHNOLOGY[tech] def GetCurrentTechnologyFamily(self): """Returns the modem technology family.""" props = self.GetAll(mm1.MODEM_INTERFACE) capabilities = props.get('SupportedCapabilities') if self._IsCDMAModem(capabilities): return cellular.TechnologyFamily.CDMA if self._Is3GPPModem(capabilities): return cellular.TechnologyFamily.UMTS raise error.TestError('Invalid modem type') def GetVersion(self): """Returns the modem version information.""" return self.GetModemProperties()['Revision'] def _IsCDMAModem(self, capabilities): return mm1_constants.MM_MODEM_CAPABILITY_CDMA_EVDO in capabilities def _Is3GPPModem(self, capabilities): for capability in capabilities: if (capability & (mm1_constants.MM_MODEM_CAPABILITY_LTE | mm1_constants.MM_MODEM_CAPABILITY_LTE_ADVANCED | mm1_constants.MM_MODEM_CAPABILITY_GSM_UMTS)): return True return False def _CDMAModemIsRegistered(self): modem_status = self.SimpleModem().GetStatus() cdma1x_state = modem_status.get( 'cdma-cdma1x-registration-state', mm1_constants.MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN) evdo_state = modem_status.get( 'cdma-evdo-registration-state', mm1_constants.MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN) return (cdma1x_state != mm1_constants.MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN or evdo_state != mm1_constants.MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN) def _3GPPModemIsRegistered(self): modem_status = self.SimpleModem().GetStatus() state = modem_status.get('m3gpp-registration-state') return (state == mm1_constants.MM_MODEM_3GPP_REGISTRATION_STATE_HOME or state == mm1_constants.MM_MODEM_3GPP_REGISTRATION_STATE_ROAMING) def ModemIsRegistered(self): """Ensure that modem is registered on the network.""" props = self.GetAll(mm1.MODEM_INTERFACE) capabilities = props.get('SupportedCapabilities') if self._IsCDMAModem(capabilities): return self._CDMAModemIsRegistered() elif self._Is3GPPModem(capabilities): return self._3GPPModemIsRegistered() else: raise error.TestError('Invalid modem type') def ModemIsRegisteredUsing(self, technology): """Ensure that modem is registered on the network with a technology.""" if not self.ModemIsRegistered(): return False reported_tech = self.GetAccessTechnology() # TODO(jglasgow): Remove this mapping. Basestation and # reported technology should be identical. BASESTATION_TO_REPORTED_TECHNOLOGY = { cellular.Technology.GPRS: cellular.Technology.GPRS, cellular.Technology.EGPRS: cellular.Technology.GPRS, cellular.Technology.WCDMA: cellular.Technology.HSDUPA, cellular.Technology.HSDPA: cellular.Technology.HSDUPA, cellular.Technology.HSUPA: cellular.Technology.HSDUPA, cellular.Technology.HSDUPA: cellular.Technology.HSDUPA, cellular.Technology.HSPA_PLUS: cellular.Technology.HSPA_PLUS } return BASESTATION_TO_REPORTED_TECHNOLOGY[technology] == reported_tech def IsConnectingOrDisconnecting(self): props = self.GetAll(mm1.MODEM_INTERFACE) return props['State'] in [ mm1.MM_MODEM_STATE_CONNECTING, mm1.MM_MODEM_STATE_DISCONNECTING ] def IsEnabled(self): props = self.GetAll(mm1.MODEM_INTERFACE) return props['State'] in [ mm1.MM_MODEM_STATE_ENABLED, mm1.MM_MODEM_STATE_SEARCHING, mm1.MM_MODEM_STATE_REGISTERED, mm1.MM_MODEM_STATE_DISCONNECTING, mm1.MM_MODEM_STATE_CONNECTING, mm1.MM_MODEM_STATE_CONNECTED ] def IsDisabled(self): props = self.GetAll(mm1.MODEM_INTERFACE) return props['State'] == mm1.MM_MODEM_STATE_DISABLED def Enable(self, enable, **kwargs): self.Modem().Enable(enable, timeout=MODEM_TIMEOUT, **kwargs) def Connect(self, props): self.SimpleModem().Connect(props, timeout=MODEM_TIMEOUT) def Disconnect(self): self.SimpleModem().Disconnect('/', timeout=MODEM_TIMEOUT) class ModemManager(object): """An object which talks to a ModemManager1 service.""" def __init__(self): self.bus = dbus.SystemBus() self.service = mm1.MODEM_MANAGER_INTERFACE self.path = mm1.OMM self.manager = dbus.Interface( self.bus.get_object(self.service, self.path), mm1.MODEM_MANAGER_INTERFACE) self.objectmanager = dbus.Interface( self.bus.get_object(self.service, self.path), mm1.OFDOM) def EnumerateDevices(self): devices = self.objectmanager.GetManagedObjects() return list(devices.keys()) def GetModem(self, path): return Modem(self, path) def SetDebugLogging(self): self.manager.SetLogging('DEBUG')