# Copyright (c) 2014 Kontron Europe GmbH # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public # License as published by the Free Software Foundation; either # version 2.1 of the License, or (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA from __future__ import absolute_import from __future__ import division import math from . import errors from .errors import DecodingError from .fields import SdrTypeLengthString from .utils import check_completion_code, ByteBuffer from .msgs import create_request_by_name from .helper import get_sdr_data_helper, clear_repository_helper from .helper import get_sdr_chunk_helper from .state import State SDR_TYPE_FULL_SENSOR_RECORD = 0x01 SDR_TYPE_COMPACT_SENSOR_RECORD = 0x02 SDR_TYPE_EVENT_ONLY_SENSOR_RECORD = 0x03 SDR_TYPE_ENTITY_ASSOCIATION_RECORD = 0x08 SDR_TYPE_FRU_DEVICE_LOCATOR_RECORD = 0x11 SDR_TYPE_MANAGEMENT_CONTROLLER_DEVICE_LOCATOR_RECORD = 0x12 SDR_TYPE_MANAGEMENT_CONTROLLER_CONFIRMATION_RECORD = 0x13 SDR_TYPE_BMC_MESSAGE_CHANNEL_INFO_RECORD = 0x14 SDR_TYPE_OEM_SENSOR_RECORD = 0xC0 GET_INITIALIZATION_AGENT_STATUS = 0 RUN_INITIALIZATION_AGENT = 1 L_LINEAR = 0 L_LN = 1 L_LOG = 2 L_LOG2 = 3 L_E = 4 L_EXP10 = 5 L_EXP2 = 6 L_1_X = 7 L_SQR = 8 L_CUBE = 9 L_SQRT = 10 L_CUBERT = 11 class Sdr(object): def __init__(self): pass def get_sdr_repository_info(self): return SdrRepositoryInfo( self.send_message_with_name('GetSdrRepositoryInfo')) def get_sdr_repository_allocation_info(self): return SdrRepositoryAllocationInfo( self.send_message_with_name('GetSdrRepositoryAllocationInfo')) def reserve_sdr_repository(self): rsp = self.send_message_with_name('ReserveSdrRepository') return rsp.reservation_id def _get_sdr_chunk(self, reservation_id, record_id, offset, length): req = create_request_by_name('GetSdr') req.reservation_id = reservation_id req.record_id = record_id req.offset = offset req.bytes_to_read = length rsp = get_sdr_chunk_helper(self.send_message, req, self.reserve_device_sdr_repository) return (rsp.next_record_id, rsp.record_data) def get_repository_sdr(self, record_id, reservation_id=None): (next_id, record_data) = get_sdr_data_helper( self.reserve_sdr_repository, self._get_sdr_chunk, record_id, reservation_id) return SdrCommon.from_data(record_data, next_id) def sdr_repository_entries(self): """A generator that returns the SDR list. The Generator starts with ID=0x0000 and ends when ID=0xffff is returned. """ reservation_id = self.reserve_sdr_repository() record_id = 0 while True: s = self.get_repository_sdr(record_id, reservation_id) yield s if s.next_id == 0xffff: break record_id = s.next_id def get_repository_sdr_list(self, reservation_id=None): """Return the complete SDR list.""" return list(self.sdr_repository_entries()) def partial_add_sdr(self, reservation_id, record_id, offset, progress, data): req = create_request_by_name('PartialAddSdr') req.reservation_id = reservation_id req.record_id = record_id req.offset = offset req.status.in_progress = progress req.data = data rsp = self.send_message(req) check_completion_code(rsp.completion_code) return rsp.record_id def delete_sdr(self, record_id): """Delete the sensor record specified by 'record_id'.""" reservation_id = self.reserve_device_sdr_repository() rsp = self.send_message_with_name('DeleteSdr', reservation_id=reservation_id, record_id=record_id) return rsp.record_id def _clear_sdr_repository(self, cmd, reservation_id): rsp = self.send_message_with_name('ClearSdrRepository', reservation_id=reservation_id, cmd=cmd) return rsp.status.erase_in_progress def clear_sdr_repository(self, retry=5): clear_repository_helper(self.reserve_sdr_repository, self._clear_sdr_repository, retry) def _run_initialization_agent(self, cmd): rsp = self.send_message_with_name('RunInitializationAgent', cmd=cmd) return rsp.status.initialization_completed def start_initialization_agent(self): self._run_initialization_agent(RUN_INITIALIZATION_AGENT) def get_initialization_agent_status(self): return self._run_initialization_agent(GET_INITIALIZATION_AGENT_STATUS) class SdrRepositoryInfo(State): def __init__(self, rsp): if rsp: self._from_response(rsp) def _from_response(self, rsp): self.sdr_version = rsp.sdr_version self.record_count = rsp.record_count self.free_space = rsp.free_space self.most_recent_addition = rsp.most_recent_addition self.support_get_allocation_info = rsp.support.get_allocation_info self.support_reserve = rsp.support.reserve self.support_partial_add = rsp.support.partial_add self.support_delete = rsp.support.delete self.support_update_type = rsp.support.update_type self.support_overflow_flag = rsp.support.overflow_flag class SdrRepositoryAllocationInfo(State): def __init__(self, rsp): if rsp: self._from_response(rsp) def _from_response(self, rsp): self.number_of_units = rsp.number_of_units self.unit_size = rsp.unit_size self.free_units = rsp.free_units self.largest_free_block = rsp.largest_free_block self.maximum_record_size = rsp.maximum_record_size class SdrCommon(object): def __init__(self, data=None, next_id=None): if data: self.data = data self._common_header(data) if hasattr(self, '_from_data'): self._from_data(data) if next_id: self.next_id = next_id def __str__(self): if hasattr(self, 'device_id_string'): s = '["%s"] [%s]' % \ (self.device_id_string, ' '.join(['%02x' % b for b in self.data])) else: s = '[%s]' % \ (' '.join(['%02x' % b for b in self.data])) return s def _common_header(self, data): buffer = ByteBuffer(data[:]) try: self.id = buffer.pop_unsigned_int(2) self.version = buffer.pop_unsigned_int(1) self.type = buffer.pop_unsigned_int(1) self.length = buffer.pop_unsigned_int(1) except IndexError: raise DecodingError('Invalid SDR length (%d)' % len(data)) def _common_record_key(self, buffer): self.owner_id = buffer.pop_unsigned_int(1) self.owner_lun = buffer.pop_unsigned_int(1) & 0x3 self.number = buffer.pop_unsigned_int(1) def _entity(self, buffer): self.entity_id = buffer.pop_unsigned_int(1) self.entity_instance = buffer.pop_unsigned_int(1) def _device_id_string(self, buffer): self.device_id_string_type = (buffer[0] & 0xc0) >> 4 self.device_id_string_length = buffer[0] & 0x3f field = SdrTypeLengthString(data=buffer[0:1+self.device_id_string_length]) self.device_id_string = field.string # self.device_id_string = \ # buffer.pop_string(self.device_id_string_length & 0x3f) @staticmethod def from_data(data, next_id=None): sdr_type = data[3] cls = { SDR_TYPE_FULL_SENSOR_RECORD: SdrFullSensorRecord, SDR_TYPE_COMPACT_SENSOR_RECORD: SdrCompactSensorRecord, SDR_TYPE_EVENT_ONLY_SENSOR_RECORD: SdrEventOnlySensorRecord, SDR_TYPE_FRU_DEVICE_LOCATOR_RECORD: SdrFruDeviceLocator, SDR_TYPE_MANAGEMENT_CONTROLLER_DEVICE_LOCATOR_RECORD: SdrManagementControllerDeviceLocator, SDR_TYPE_MANAGEMENT_CONTROLLER_CONFIRMATION_RECORD: SdrManagementControllerConfirmationRecord, SDR_TYPE_OEM_SENSOR_RECORD: SdrOEMSensorRecord, }.get(sdr_type, SdrUnknownSensorRecord) return cls(data, next_id) ### # SDR type 0x01 ################################################## class SdrFullSensorRecord(SdrCommon): DATA_FMT_UNSIGNED = 0 DATA_FMT_1S_COMPLEMENT = 1 DATA_FMT_2S_COMPLEMENT = 2 DATA_FMT_NONE = 3 def __init__(self, data=None, next_id=None): super(SdrFullSensorRecord, self).__init__(data, next_id) def __str__(self): s = '["%s"] [%s:%s] [%s]' \ % (self.device_id_string, self.entity_id, self.entity_instance, ' '.join(['%02x' % b for b in self.data])) return s def convert_sensor_raw_to_value(self, raw): if raw is None: return None fmt = self.analog_data_format if (fmt == self.DATA_FMT_1S_COMPLEMENT): if raw & 0x80: raw = -((raw & 0x7f) ^ 0x7f) elif (fmt == self.DATA_FMT_2S_COMPLEMENT): if raw & 0x80: raw = -((raw & 0x7f) ^ 0x7f) - 1 raw = float(raw) return self.lin((self.m * raw + (self.b * 10**self.k1)) * 10**self.k2) def convert_sensor_value_to_raw(self, value): linearization = self.linearization & 0x7f if linearization is not L_LINEAR: raise NotImplementedError() raw = ((float(value) * 10**(-1 * self.k2)) / self.m) - (self.b * 10**self.k1) raw = int(round(raw)) fmt = self.analog_data_format if (fmt == self.DATA_FMT_1S_COMPLEMENT): if value < 0: raw = (-raw ^ 0x7f) | 0x80 elif (fmt == self.DATA_FMT_2S_COMPLEMENT): if value < 0: raw = (-(raw + 1) ^ 0x7f) | 0x80 if raw > 0xff: raise ValueError() return raw @property def lin(self): try: return { L_LN: math.log, L_LOG: lambda x: math.log(x, 10), L_LOG2: lambda x: math.log(x, 2), L_E: math.exp, L_EXP10: lambda x: math.pow(10, x), L_EXP2: lambda x: math.pow(2, x), L_1_X: lambda x: 1.0 / x, L_SQR: lambda x: math.pow(x, 2), L_CUBE: lambda x: math.pow(x, 3), L_SQRT: math.sqrt, L_CUBERT: lambda x: math.pow(x, 1.0/3), L_LINEAR: lambda x: x, }[self.linearization & 0x7f] except KeyError: raise errors.DecodingError('unknown linearization %d' % (self.linearization & 0x7f)) @staticmethod def _convert_complement(value, size): if (value & (1 << (size - 1))): value = -(1 << size) + value return value def _decode_capabilities(self, capabilities): self.capabilities = [] # ignore sensor if capabilities & 0x80: self.capabilities.append('ignore_sensor') # sensor auto re-arm support if capabilities & 0x40: self.capabilities.append('auto_rearm') # sensor hysteresis support HYSTERESIS_MASK = 0x30 HYSTERESIS_IS_NOT_SUPPORTED = 0x00 HYSTERESIS_IS_READABLE = 0x10 HYSTERESIS_IS_READ_AND_SETTABLE = 0x20 HYSTERESIS_IS_FIXED = 0x30 if capabilities & HYSTERESIS_MASK == HYSTERESIS_IS_NOT_SUPPORTED: self.capabilities.append('hysteresis_not_supported') elif capabilities & HYSTERESIS_MASK == HYSTERESIS_IS_READABLE: self.capabilities.append('hysteresis_readable') elif capabilities & HYSTERESIS_MASK == HYSTERESIS_IS_READ_AND_SETTABLE: self.capabilities.append('hysteresis_read_and_setable') elif capabilities & HYSTERESIS_MASK == HYSTERESIS_IS_FIXED: self.capabilities.append('hysteresis_fixed') # sensor threshold support THRESHOLD_MASK = 0x0C THRESHOLD_IS_NOT_SUPPORTED = 0x00 THRESHOLD_IS_READABLE = 0x08 THRESHOLD_IS_READ_AND_SETTABLE = 0x04 THRESHOLD_IS_FIXED = 0x0C if capabilities & THRESHOLD_MASK == THRESHOLD_IS_NOT_SUPPORTED: self.capabilities.append('threshold_not_supported') elif capabilities & THRESHOLD_MASK == THRESHOLD_IS_READABLE: self.capabilities.append('threshold_readable') elif capabilities & THRESHOLD_MASK == THRESHOLD_IS_READ_AND_SETTABLE: self.capabilities.append('threshold_read_and_setable') elif capabilities & THRESHOLD_MASK == THRESHOLD_IS_FIXED: self.capabilities.append('threshold_fixed') # sensor event message control support if (capabilities & 0x03) == 0: pass if (capabilities & 0x03) == 1: pass if (capabilities & 0x03) == 2: pass if (capabilities & 0x03) == 3: pass def _from_data(self, data): buffer = ByteBuffer(data[5:]) # record key bytes self._common_record_key(buffer.pop_slice(3)) # record body bytes self._entity(buffer.pop_slice(2)) # byte 11 initialization = buffer.pop_unsigned_int(1) self.initialization = [] if initialization & 0x40: self.initialization.append('scanning') if initialization & 0x20: self.initialization.append('events') if initialization & 0x10: self.initialization.append('thresholds') if initialization & 0x08: self.initialization.append('hysteresis') if initialization & 0x04: self.initialization.append('type') if initialization & 0x02: self.initialization.append('default_event_generation') if initialization & 0x01: self.initialization.append('default_scanning') # byte 12 - sensor capabilities self._decode_capabilities(buffer.pop_unsigned_int(1)) self.sensor_type_code = buffer.pop_unsigned_int(1) self.event_reading_type_code = buffer.pop_unsigned_int(1) self.assertion_mask = buffer.pop_unsigned_int(2) self.deassertion_mask = buffer.pop_unsigned_int(2) self.discrete_reading_mask = buffer.pop_unsigned_int(2) # byte 21, 22, 23 self.units_1 = buffer.pop_unsigned_int(1) self.units_2 = buffer.pop_unsigned_int(1) self.units_3 = buffer.pop_unsigned_int(1) self.analog_data_format = (self.units_1 >> 6) & 0x3 self.rate_unit = (self.units_1 >> 3) >> 0x7 self.modifier_unit = (self.units_1 >> 1) & 0x2 self.percentage = self.units_1 & 0x1 # byte 24 self.linearization = buffer.pop_unsigned_int(1) & 0x7f # byte 25, 26 m = buffer.pop_unsigned_int(1) m_tol = buffer.pop_unsigned_int(1) self.m = (m & 0xff) | ((m_tol & 0xc0) << 2) # NAC: Bug fix. Upstream did not properly account for # 'M' being a twos complement value. self.m = self._convert_complement(self.m, 10) self.tolerance = (m_tol & 0x3f) # byte 27, 28, 29 b = buffer.pop_unsigned_int(1) b_acc = buffer.pop_unsigned_int(1) acc_accexp = buffer.pop_unsigned_int(1) self.b = (b & 0xff) | ((b_acc & 0xc0) << 2) self.b = self._convert_complement(self.b, 10) self.accuracy = (b_acc & 0x3f) | ((acc_accexp & 0xf0) << 4) self.accuracy_exp = (acc_accexp & 0x0c) >> 2 # byte 30 rexp_bexp = buffer.pop_unsigned_int(1) self.k2 = (rexp_bexp & 0xf0) >> 4 # convert 2s complement self.k2 = self._convert_complement(self.k2, 4) self.k1 = rexp_bexp & 0x0f # convert 2s complement self.k1 = self._convert_complement(self.k1, 4) # byte 31 analog_characteristics = buffer.pop_unsigned_int(1) self.analog_characteristic = [] if analog_characteristics & 0x01: self.analog_characteristic.append('nominal_reading') if analog_characteristics & 0x02: self.analog_characteristic.append('normal_max') if analog_characteristics & 0x04: self.analog_characteristic.append('normal_min') self.nominal_reading = buffer.pop_unsigned_int(1) self.normal_maximum = buffer.pop_unsigned_int(1) self.normal_minimum = buffer.pop_unsigned_int(1) self.sensor_maximum_reading = buffer.pop_unsigned_int(1) self.sensor_minimum_reading = buffer.pop_unsigned_int(1) self.threshold = {} self.threshold['unr'] = buffer.pop_unsigned_int(1) self.threshold['ucr'] = buffer.pop_unsigned_int(1) self.threshold['unc'] = buffer.pop_unsigned_int(1) self.threshold['lnr'] = buffer.pop_unsigned_int(1) self.threshold['lcr'] = buffer.pop_unsigned_int(1) self.threshold['lnc'] = buffer.pop_unsigned_int(1) self.hysteresis = {} self.hysteresis['positive_going'] = buffer.pop_unsigned_int(1) self.hysteresis['negative_going'] = buffer.pop_unsigned_int(1) self.reserved = buffer.pop_unsigned_int(2) self.oem = buffer.pop_unsigned_int(1) self._device_id_string(buffer) ### # SDR type 0x02 ################################################## class SdrCompactSensorRecord(SdrCommon): def __init__(self, data=None, next_id=None): super(SdrCompactSensorRecord, self).__init__(data, next_id) def __str__(self): s = '["%s"] [%s]' \ % (self.device_id_string, ' '.join(['%02x' % b for b in self.data])) return s def _from_data(self, data): buffer = ByteBuffer(data[5:]) # record key bytes self._common_record_key(buffer.pop_slice(3)) # record body bytes self._entity(buffer.pop_slice(2)) self.sensor_initialization = buffer.pop_unsigned_int(1) self.capabilities = buffer.pop_unsigned_int(1) self.sensor_type_code = buffer.pop_unsigned_int(1) self.event_reading_type_code = buffer.pop_unsigned_int(1) self.assertion_mask = buffer.pop_unsigned_int(2) self.deassertion_mask = buffer.pop_unsigned_int(2) self.discrete_reading_mask = buffer.pop_unsigned_int(2) self.units_1 = buffer.pop_unsigned_int(1) self.units_2 = buffer.pop_unsigned_int(1) self.units_3 = buffer.pop_unsigned_int(1) self.record_sharing = buffer.pop_unsigned_int(2) self.positive_going_hysteresis = buffer.pop_unsigned_int(1) self.negative_going_hysteresis = buffer.pop_unsigned_int(1) self.reserved = buffer.pop_unsigned_int(3) self.oem = buffer.pop_unsigned_int(1) self._device_id_string(buffer) ### # SDR type 0x03 ################################################## class SdrEventOnlySensorRecord(SdrCommon): def __init__(self, data=None, next_id=None): super(SdrEventOnlySensorRecord, self).__init__(data, next_id) def __str__(self): return 'Not supported yet.' def _from_data(self, data): buffer = ByteBuffer(data[5:]) # record key bytes self._common_record_key(buffer.pop_slice(3)) # record body bytes self._entity(buffer.pop_slice(2)) self.sensor_type = buffer.pop_unsigned_int(1) self.event_reading_type_code = buffer.pop_unsigned_int(1) self.record_sharing = buffer.pop_unsigned_int(2) self.reserved = buffer.pop_unsigned_int(1) self.oem = buffer.pop_unsigned_int(1) self._device_id_string(buffer) ### # SDR type 0x11 ################################################## class SdrFruDeviceLocator(SdrCommon): def __init__(self, data=None, next_id=None): super(SdrFruDeviceLocator, self).__init__(data, next_id) def __str__(self): s = '["%s"] [%s]' \ % (self.device_id_string, ' '.join(['%02x' % b for b in self.data])) return s def _from_data(self, data): buffer = ByteBuffer(data[5:]) self.device_access_address = buffer.pop_unsigned_int(1) >> 1 self.fru_device_id = buffer.pop_unsigned_int(1) self.logical_physical = buffer.pop_unsigned_int(1) self.channel_number = buffer.pop_unsigned_int(1) self.reserved = buffer.pop_unsigned_int(1) self.device_type = buffer.pop_unsigned_int(1) self.device_type_modifier = buffer.pop_unsigned_int(1) self._entity(buffer.pop_slice(2)) self.oem = buffer.pop_unsigned_int(1) self._device_id_string(buffer) ### # SDR type 0x12 ################################################## class SdrManagementControllerDeviceLocator(SdrCommon): def __init__(self, data=None, next_id=None): super(SdrManagementControllerDeviceLocator, self).__init__( data, next_id) def __str__(self): s = '["%s"] [%s]' \ % (self.device_id_string, ' '.join(['%02x' % b for b in self.data])) return s def _from_data(self, data): buffer = ByteBuffer(data[5:]) self.device_slave_address = buffer.pop_unsigned_int(1) >> 1 self.channel_number = buffer.pop_unsigned_int(1) & 0xf self.power_state_notification = buffer.pop_unsigned_int(1) self.global_initialization = 0 self.device_capabilities = buffer.pop_unsigned_int(1) self.reserved = buffer.pop_unsigned_int(3) self._entity(buffer.pop_slice(2)) self.oem = buffer.pop_unsigned_int(1) self._device_id_string(buffer) ### # SDR type 0x13 ################################################## class SdrManagementControllerConfirmationRecord(SdrCommon): def __init__(self, data=None, next_id=None): super(SdrManagementControllerConfirmationRecord, self).__init__( data, next_id) def _from_data(self, data): buffer = ByteBuffer(data[5:]) self.device_slave_address = buffer.pop_unsigned_int(1) >> 1 self.device_id = buffer.pop_unsigned_int(1) self.channel_number = buffer.pop_unsigned_int(1) self.firmware_revision_1 = buffer.pop_unsigned_int(1) self.firmware_revision_2 = buffer.pop_unsigned_int(1) self.ipmi_version = buffer.pop_unsigned_int(1) self.manufacturer_id = buffer.pop_unsigned_int(3) & 0xfffff self.product_id = buffer.pop_unsigned_int(2) self.device_guid = buffer.pop_unsigned_int(16) ### # SDR type 0xC0 ################################################## class SdrOEMSensorRecord(SdrCommon): def __init__(self, data=None, next_id=None): super(SdrOEMSensorRecord, self).__init__(data, next_id) def __str__(self): return 'Not supported yet.' def _from_data(self, data): buffer = ByteBuffer(data[5:]) # record key bytes self._common_record_key(buffer.pop_slice(3)) # Any SDR type not known or not implemented class SdrUnknownSensorRecord(SdrCommon): def __init__(self, data=None, next_id=None): super(SdrUnknownSensorRecord, self).__init__(data, next_id) def __str__(self): return 'Not supported yet.'