| # 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. |
| |
| import dbus |
| import dbus.types |
| import logging |
| |
| import modem |
| import pm_constants |
| import utils |
| |
| from autotest_lib.client.cros.cellular import mm1_constants |
| |
| class ModemCdma(modem.Modem): |
| """ |
| Pseudomodem implementation of the |
| org.freedesktop.ModemManager1.Modem.ModemCdma and |
| org.freedesktop.ModemManager1.Modem.Simple interfaces. This class provides |
| access to specific actions that may be performed in modems with CDMA |
| capabilities. |
| |
| """ |
| |
| class CdmaNetwork(object): |
| """ |
| Stores carrier specific information needed for a CDMA network. |
| |
| """ |
| def __init__(self, |
| sid=99998, |
| nid=0, |
| activated=True, |
| mdn='5555555555', |
| standard='evdo'): |
| self.sid = sid |
| self.nid = nid |
| self.standard = standard |
| self.activated = activated |
| self._mdn = mdn |
| |
| |
| @property |
| def mdn(self): |
| """ |
| @returns: The 'Mobile Directory Number' assigned to this modem by |
| the carrier. If not activated, the first 6 digits will |
| contain '0'. |
| |
| """ |
| if self.activated: |
| return self._mdn |
| return '000000' + self._mdn[6:] |
| |
| |
| def __init__(self, |
| state_machine_factory=None, |
| home_network=CdmaNetwork(), |
| bus=None, |
| device='pseudomodem0', |
| roaming_networks=None, |
| config=None): |
| self.home_network = home_network |
| self.cdma_activate_step = None |
| modem.Modem.__init__(self, |
| state_machine_factory, |
| bus=bus, |
| device=device, |
| roaming_networks=roaming_networks, |
| config=config) |
| |
| |
| def _InitializeProperties(self): |
| ip = modem.Modem._InitializeProperties(self) |
| if self.home_network and self.home_network.activated: |
| activation_state = \ |
| mm1_constants.MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATED |
| else: |
| activation_state = \ |
| mm1_constants.MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED |
| ip[mm1_constants.I_MODEM_CDMA] = { |
| 'Meid' : 'A100000DCE2CA0', |
| 'Esn' : 'EDD1EDD1', |
| 'Sid' : dbus.types.UInt32(0), |
| 'Nid' : dbus.types.UInt32(0), |
| 'Cdma1xRegistrationState' : ( |
| dbus.types.UInt32( |
| mm1_constants.MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN)), |
| 'EvdoRegistrationState' : ( |
| dbus.types.UInt32( |
| mm1_constants.MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN)), |
| 'ActivationState' : dbus.types.UInt32(activation_state) |
| } |
| props = ip[mm1_constants.I_MODEM] |
| props['SupportedCapabilities'] = [ |
| dbus.types.UInt32(mm1_constants.MM_MODEM_CAPABILITY_CDMA_EVDO) |
| ] |
| props['CurrentCapabilities'] = ( |
| dbus.types.UInt32(mm1_constants.MM_MODEM_CAPABILITY_CDMA_EVDO)) |
| props['MaxBearers'] = dbus.types.UInt32(1) |
| props['MaxActiveBearers'] = dbus.types.UInt32(1) |
| props['EquipmentIdentifier'] = ip[mm1_constants.I_MODEM_CDMA]['Meid'] |
| props['AccessTechnologies'] = ( |
| dbus.types.UInt32(mm1_constants.MM_MODEM_ACCESS_TECHNOLOGY_EVDO0)) |
| props['SupportedModes'] = [ |
| dbus.types.Struct( |
| [dbus.types.UInt32(mm1_constants.MM_MODEM_MODE_3G), |
| dbus.types.UInt32(mm1_constants.MM_MODEM_MODE_4G)], |
| signature='uu') |
| ] |
| props['CurrentModes'] = props['SupportedModes'][0] |
| props['SupportedBands'] = [ |
| dbus.types.UInt32( |
| mm1_constants.MM_MODEM_BAND_CDMA_BC0_CELLULAR_800), |
| dbus.types.UInt32(mm1_constants.MM_MODEM_BAND_CDMA_BC1_PCS_1900), |
| dbus.types.UInt32(mm1_constants.MM_MODEM_BAND_CDMA_BC2_TACS), |
| dbus.types.UInt32(mm1_constants.MM_MODEM_BAND_CDMA_BC3_JTACS), |
| dbus.types.UInt32(mm1_constants.MM_MODEM_BAND_CDMA_BC4_KOREAN_PCS), |
| dbus.types.UInt32(mm1_constants.MM_MODEM_BAND_CDMA_BC5_NMT450), |
| dbus.types.UInt32(mm1_constants.MM_MODEM_BAND_CDMA_BC6_IMT2000), |
| dbus.types.UInt32( |
| mm1_constants.MM_MODEM_BAND_CDMA_BC7_CELLULAR_700), |
| dbus.types.UInt32(mm1_constants.MM_MODEM_BAND_CDMA_BC8_1800), |
| dbus.types.UInt32(mm1_constants.MM_MODEM_BAND_CDMA_BC9_900), |
| dbus.types.UInt32( |
| mm1_constants.MM_MODEM_BAND_CDMA_BC10_SECONDARY_800), |
| dbus.types.UInt32(mm1_constants.MM_MODEM_BAND_CDMA_BC11_PAMR_400) |
| ] |
| props['CurrentBands'] = [ |
| dbus.types.UInt32( |
| mm1_constants.MM_MODEM_BAND_CDMA_BC0_CELLULAR_800), |
| dbus.types.UInt32(mm1_constants.MM_MODEM_BAND_CDMA_BC1_PCS_1900), |
| ] |
| if self.home_network: |
| props['OwnNumbers'] = [self.home_network.mdn] |
| else: |
| props['OwnNumbers'] = [] |
| |
| return ip |
| |
| |
| @utils.log_dbus_method(return_cb_arg='return_cb', raise_cb_arg='raise_cb') |
| @dbus.service.method(mm1_constants.I_MODEM_CDMA, in_signature='s', |
| async_callbacks=('return_cb', 'raise_cb')) |
| def Activate(self, carrier, return_cb, raise_cb): |
| """ |
| Provisions the modem for use with a given carrier using the modem's |
| OTA activation functionality, if any. |
| |
| @param carrier: Automatic activation code. |
| @param return_cb: Asynchronous success callback. |
| @param raise_cb: Asynchronous failure callback. Has to take an instance |
| of Exception or Error. |
| Emits: |
| ActivationStateChanged |
| |
| """ |
| logging.info('ModemCdma.Activate') |
| machine = self._state_machine_factory.CreateMachine( |
| pm_constants.STATE_MACHINE_CDMA_ACTIVATE, |
| self, |
| return_cb, |
| raise_cb) |
| machine.Start() |
| |
| |
| @utils.log_dbus_method() |
| @dbus.service.method(mm1_constants.I_MODEM_CDMA, in_signature='a{sv}') |
| def ActivateManual(self, properties): |
| """ |
| Sets the modem provisioning data directly, without contacting the |
| carrier over the air. Some modems will reboot after this call is made. |
| |
| @param properties: A dictionary of properties to set on the modem, |
| including "mdn" and "min". |
| Emits: |
| ActivationStateChanged |
| |
| """ |
| raise NotImplementedError() |
| |
| |
| @dbus.service.signal(mm1_constants.I_MODEM_CDMA, signature='uua{sv}') |
| def ActivationStateChanged( |
| self, |
| activation_state, |
| activation_error, |
| status_changes): |
| """ |
| The device activation state changed. |
| |
| @param activation_state: Current activation state, given as a |
| MMModemCdmaActivationState. |
| @param activation_error: Carrier-specific error code, given as a |
| MMCdmaActivationError. |
| @param status_changes: Properties that have changed as a result of this |
| activation state chage, including "mdn" and "min". |
| |
| """ |
| logging.info('ModemCdma: activation state changed: state: %u, error: ' |
| '%u, status_changes: %s', |
| activation_state, |
| activation_error, |
| str(status_changes)) |
| |
| |
| def IsPendingActivation(self): |
| """ |
| @returns: True, if a CdmaActivationMachine is currently active. |
| |
| """ |
| return self.cdma_activate_step and \ |
| not self.cdma_activate_step.cancelled |
| |
| |
| def ChangeActivationState(self, state, error): |
| """ |
| Changes the activation state of this modem to the one provided. |
| |
| If the requested state is MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATED and |
| a cdma_activation_machine.CdmaActivationMachine associated with this |
| modem is currently active, then this method won't update the DBus |
| properties until after the modem has reset. |
| |
| @param state: Requested activation state, given as a |
| MMModemCdmaActivationState. |
| @param error: Carrier-specific error code, given as a |
| MMCdmaActivationError. |
| |
| """ |
| status_changes = {} |
| if state == mm1_constants.MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATED: |
| self.home_network.activated = True |
| status_changes['mdn'] = [self.home_network.mdn] |
| self.Set(mm1_constants.I_MODEM, 'OwnNumbers', status_changes['mdn']) |
| |
| if self.IsPendingActivation(): |
| logging.info("A CdmaActivationMachine is currently active. " |
| "Deferring setting the 'ActivationState' property" |
| " to ACTIVATED until after the reset is " |
| "complete.") |
| return |
| |
| self.SetUInt32(mm1_constants.I_MODEM_CDMA, 'ActivationState', state) |
| self.ActivationStateChanged(state, error, status_changes) |
| |
| |
| def GetHomeNetwork(self): |
| """ |
| @returns: A instance of CdmaNetwork that represents the |
| current home network that is assigned to this modem. |
| |
| """ |
| return self.home_network |
| |
| |
| def SetRegistered(self, network): |
| """ |
| Sets the modem to be registered on the given network. Configures the |
| 'ActivationState', 'Sid', and 'Nid' properties accordingly. |
| |
| @param network: An instance of CdmaNetwork. |
| |
| """ |
| logging.info('ModemCdma.SetRegistered') |
| if network: |
| state = mm1_constants.MM_MODEM_CDMA_REGISTRATION_STATE_HOME |
| sid = network.sid |
| nid = network.nid |
| if network.activated: |
| activation_state = \ |
| mm1_constants.MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATED |
| else: |
| activation_state = \ |
| mm1_constants.MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED |
| else: |
| state = mm1_constants.MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN |
| sid = 0 |
| nid = 0 |
| activation_state = \ |
| mm1_constants.MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED |
| self.SetUInt32(mm1_constants.I_MODEM_CDMA, 'ActivationState', |
| activation_state) |
| self.SetUInt32(mm1_constants.I_MODEM_CDMA, 'Sid', sid) |
| self.SetUInt32(mm1_constants.I_MODEM_CDMA, 'Nid', nid) |
| self.SetRegistrationState(state) |
| |
| |
| def SetRegistrationState(self, state): |
| """ |
| Sets the CDMA1x and EVDO registration states to the provided value. |
| |
| @param state: A MMModemCdmaRegistrationState value. |
| |
| """ |
| self.SetUInt32(mm1_constants.I_MODEM_CDMA, 'Cdma1xRegistrationState', |
| state) |
| self.SetUInt32(mm1_constants.I_MODEM_CDMA, 'EvdoRegistrationState', |
| state) |
| |
| |
| # Inherited from modem.Modem. |
| def RegisterWithNetwork( |
| self, operator_id="", return_cb=None, raise_cb=None): |
| """ Overridden from superclass. |
| |
| @param operator_id: See superclass. |
| @param return_cb: See superclass. |
| @param raise_cb: See superclass. |
| |
| """ |
| logging.info('ModemCdma.RegisterWithNetwork') |
| machine = self._state_machine_factory.CreateMachine( |
| pm_constants.STATE_MACHINE_REGISTER_CDMA, |
| self, |
| operator_id, |
| return_cb, |
| raise_cb) |
| machine.Start() |
| |
| |
| def UnregisterWithNetwork(self): |
| """ Overridden from superclass. """ |
| logging.info('ModemCdma.UnregisterWithNetwork') |
| if self.Get(mm1_constants.I_MODEM, 'State') != \ |
| mm1_constants.MM_MODEM_STATE_REGISTERED: |
| logging.info('Currently not registered. Nothing to do.') |
| return |
| logging.info('Setting state to ENABLED.') |
| self.ChangeState(mm1_constants.MM_MODEM_STATE_ENABLED, |
| mm1_constants.MM_MODEM_STATE_CHANGE_REASON_USER_REQUESTED) |
| logging.info('Unregistering.') |
| self.SetRegistered(None) |
| |
| |
| # Inherited from modem_simple.ModemSimple. |
| @utils.log_dbus_method(return_cb_arg='return_cb', raise_cb_arg='raise_cb') |
| def Connect(self, properties, return_cb, raise_cb): |
| """ |
| Overridden from superclass. |
| |
| @param properties |
| @param return_cb |
| @param raise_cb |
| |
| """ |
| logging.info('ModemCdma.Connect') |
| machine = self._state_machine_factory.CreateMachine( |
| pm_constants.STATE_MACHINE_CONNECT_CDMA, |
| self, |
| properties, |
| return_cb, |
| raise_cb) |
| machine.Start() |
| |
| |
| # Inherited from modem_simple.ModemSimple. |
| @utils.log_dbus_method(return_cb_arg='return_cb', raise_cb_arg='raise_cb') |
| def Disconnect(self, bearer_path, return_cb, raise_cb, *return_cb_args): |
| """ |
| Overridden from superclass. |
| |
| @param bearer_path |
| @param return_cb |
| @param raise_cb |
| @param return_cb_args |
| |
| """ |
| logging.info('ModemCdma.Disconnect: %s', bearer_path) |
| machine = self._state_machine_factory.CreateMachine( |
| pm_constants.STATE_MACHINE_DISCONNECT, |
| self, |
| bearer_path, |
| return_cb, |
| raise_cb, |
| return_cb_args) |
| machine.Start() |
| |
| |
| # Inherited from modem_simple.ModemSimple. |
| @utils.log_dbus_method() |
| def GetStatus(self): |
| """ Overridden from superclass. """ |
| modem_props = self.GetAll(mm1_constants.I_MODEM) |
| cdma_props = self.GetAll(mm1_constants.I_MODEM_CDMA) |
| retval = {} |
| retval['state'] = modem_props['State'] |
| if retval['state'] >= mm1_constants.MM_MODEM_STATE_REGISTERED: |
| retval['signal-quality'] = modem_props['SignalQuality'][0] |
| retval['bands'] = modem_props['CurrentBands'] |
| retval['cdma-cdma1x-registration-state'] = \ |
| cdma_props['Cdma1xRegistrationState'] |
| retval['cdma-evdo-registration-state'] = \ |
| cdma_props['EvdoRegistrationState'] |
| retval['cdma-sid'] = cdma_props['Sid'] |
| retval['cdma-nid'] = cdma_props['Nid'] |
| return retval |
