You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
264 lines
10 KiB
264 lines
10 KiB
#!/usr/bin/python2
|
|
# 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 autotest_lib.client.common_lib import error
|
|
from autotest_lib.client.cros.cellular import cellular
|
|
from autotest_lib.client.cros.cellular import mm1
|
|
from autotest_lib.client.cros.cellular import mm1_constants
|
|
import dbus
|
|
import cellular_logging
|
|
|
|
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 src.iteritems():
|
|
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 devices.keys()
|
|
|
|
def GetModem(self, path):
|
|
return Modem(self, path)
|
|
|
|
def SetDebugLogging(self):
|
|
self.manager.SetLogging('DEBUG')
|