202 lines
6.3 KiB
Python
202 lines
6.3 KiB
Python
# Copyright 2018 Intel, Inc.
|
|
# All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
from sushy.resources import base
|
|
|
|
from rsd_lib import base as rsd_lib_base
|
|
from rsd_lib import utils as rsd_lib_utils
|
|
|
|
|
|
class IntelRackScaleField(base.CompositeField):
|
|
|
|
voltage_volt = base.Field("VoltageVolt", adapter=rsd_lib_utils.num_or_none)
|
|
"""This indicates current voltage of memory module"""
|
|
|
|
|
|
class OemField(base.CompositeField):
|
|
|
|
intel_rackscale = IntelRackScaleField("Intel_RackScale")
|
|
"""Intel Rack Scale Design specific properties."""
|
|
|
|
|
|
class MemoryLocationField(base.CompositeField):
|
|
|
|
socket = base.Field("Socket", adapter=rsd_lib_utils.num_or_none)
|
|
"""Socket number in which Memory is connected"""
|
|
|
|
memory_controller = base.Field(
|
|
"MemoryController", adapter=rsd_lib_utils.num_or_none
|
|
)
|
|
"""Memory controller number in which Memory is connected"""
|
|
|
|
channel = base.Field("Channel", adapter=rsd_lib_utils.num_or_none)
|
|
"""Channel number in which Memory is connected"""
|
|
|
|
slot = base.Field("Slot", adapter=rsd_lib_utils.num_or_none)
|
|
"""Slot number in which Memory is connected"""
|
|
|
|
|
|
class RegionSetCollectionField(base.ListField):
|
|
"""RegionSet field
|
|
|
|
Memory memory region information.
|
|
"""
|
|
|
|
region_id = base.Field("RegionId")
|
|
"""Unique region ID representing a specific region within the Memory"""
|
|
|
|
memory_classification = base.Field("MemoryClassification")
|
|
"""Classification of memory occupied by the given memory region"""
|
|
|
|
offset_mib = base.Field("OffsetMiB", adapter=rsd_lib_utils.num_or_none)
|
|
"""Offset with in the Memory that corresponds to the starting of this
|
|
memory region in MiB
|
|
"""
|
|
|
|
size_mib = base.Field("SizeMiB", adapter=rsd_lib_utils.num_or_none)
|
|
"""Size of this memory region in MiB"""
|
|
|
|
passphrase_state = base.Field("PassphraseState", adapter=bool)
|
|
"""State of the passphrase for this region"""
|
|
|
|
|
|
class Memory(rsd_lib_base.ResourceBase):
|
|
"""Memory resource class
|
|
|
|
This is the schema definition for definition of a Memory and its
|
|
configuration
|
|
"""
|
|
|
|
memory_type = base.Field("MemoryType")
|
|
"""The type of Memory"""
|
|
|
|
memory_device_type = base.Field("MemoryDeviceType")
|
|
"""Type details of the Memory"""
|
|
|
|
base_module_type = base.Field("BaseModuleType")
|
|
"""The base module type of Memory"""
|
|
|
|
memory_media = base.Field("MemoryMedia")
|
|
"""Media of this Memory"""
|
|
|
|
capacity_mib = base.Field("CapacityMiB", adapter=rsd_lib_utils.num_or_none)
|
|
"""Memory Capacity in MiB."""
|
|
|
|
data_width_bits = base.Field(
|
|
"DataWidthBits", adapter=rsd_lib_utils.num_or_none
|
|
)
|
|
"""Data Width in bits."""
|
|
|
|
bus_width_bits = base.Field(
|
|
"BusWidthBits", adapter=rsd_lib_utils.num_or_none
|
|
)
|
|
"""Bus Width in bits."""
|
|
|
|
manufacturer = base.Field("Manufacturer")
|
|
"""The Memory manufacturer"""
|
|
|
|
serial_number = base.Field("SerialNumber")
|
|
"""The product serial number of this device"""
|
|
|
|
part_number = base.Field("PartNumber")
|
|
"""The product part number of this device"""
|
|
|
|
allowed_speeds_mhz = base.Field("AllowedSpeedsMHz")
|
|
"""Speed bins supported by this Memory"""
|
|
|
|
firmware_revision = base.Field("FirmwareRevision")
|
|
"""Revision of firmware on the Memory controller"""
|
|
|
|
firmware_api_version = base.Field("FirmwareApiVersion")
|
|
"""Version of API supported by the firmware"""
|
|
|
|
function_classes = base.Field("FunctionClasses")
|
|
"""Function Classes by the Memory"""
|
|
|
|
vendor_id = base.Field("VendorID")
|
|
"""Vendor ID"""
|
|
|
|
device_id = base.Field("DeviceID")
|
|
"""Device ID"""
|
|
|
|
subsystem_vendor_id = base.Field("SubsystemVendorID")
|
|
"""SubSystem Vendor ID"""
|
|
|
|
subsystem_device_id = base.Field("SubsystemDeviceID")
|
|
"""Subsystem Device ID"""
|
|
|
|
max_tdp_milli_watts = base.Field("MaxTDPMilliWatts")
|
|
"""Maximum TDPs in milli Watts"""
|
|
|
|
spare_device_count = base.Field(
|
|
"SpareDeviceCount", adapter=rsd_lib_utils.num_or_none
|
|
)
|
|
"""Number of unused spare devices available in the Memory"""
|
|
|
|
rank_count = base.Field("RankCount", adapter=rsd_lib_utils.num_or_none)
|
|
"""Number of ranks available in the Memory"""
|
|
|
|
device_locator = base.Field("DeviceLocator")
|
|
"""Location of the Memory in the platform"""
|
|
|
|
memory_location = MemoryLocationField("MemoryLocation")
|
|
"""Memory connection information to sockets and memory controllers."""
|
|
|
|
error_correction = base.Field("ErrorCorrection")
|
|
"""Error correction scheme supported for this memory"""
|
|
|
|
operating_speed_mhz = base.Field(
|
|
"OperatingSpeedMhz", adapter=rsd_lib_utils.num_or_none
|
|
)
|
|
"""Operating speed of Memory in MHz"""
|
|
|
|
volatile_region_size_limit_mib = base.Field(
|
|
"VolatileRegionSizeLimitMiB", adapter=rsd_lib_utils.num_or_none
|
|
)
|
|
"""Total size of volatile regions in MiB"""
|
|
|
|
persistent_region_size_limit_mib = base.Field(
|
|
"PersistentRegionSizeLimitMiB", adapter=rsd_lib_utils.num_or_none
|
|
)
|
|
"""Total size of persistent regions in MiB"""
|
|
|
|
regions = RegionSetCollectionField("Regions")
|
|
"""Memory regions information within the Memory"""
|
|
|
|
operating_memory_modes = base.Field("OperatingMemoryModes")
|
|
"""Memory modes supported by the Memory"""
|
|
|
|
is_spare_device_enabled = base.Field("IsSpareDeviceEnabled", adapter=bool)
|
|
"""Spare device enabled status"""
|
|
|
|
is_rank_spare_enabled = base.Field("IsRankSpareEnabled", adapter=bool)
|
|
"""Rank spare enabled status"""
|
|
|
|
status = rsd_lib_base.StatusField("Status")
|
|
"""This indicates the known state of the resource, such as if it is
|
|
enabled.
|
|
"""
|
|
|
|
oem = OemField("Oem")
|
|
"""Oem specific properties."""
|
|
|
|
# TODO(linyang): Add Action Field
|
|
|
|
|
|
class MemoryCollection(rsd_lib_base.ResourceCollectionBase):
|
|
@property
|
|
def _resource_type(self):
|
|
return Memory
|