7f4ab8fbd8
Submodule updates include the following commits: * src/sonic-utilities 9dc58ea...f9eb739 (18): > Remove unnecessary calls to str.encode() now that the package is Python 3; Fix deprecation warning (#1260) > [generate_dump] Ignoring file/directory not found Errors (#1201) > Fixed porstat rate and util issues (#1140) > fix error: interface counters is mismatch after warm-reboot (#1099) > Remove unnecessary calls to str.decode() now that the package is Python 3 (#1255) > [acl-loader] Make list sorting compliant with Python 3 (#1257) > Replace hard-coded fast-reboot with variable. And some typo corrections (#1254) > [configlet][portconfig] Remove calls to dict.has_key() which is not available in Python 3 (#1247) > Remove unnecessary conversions to list() and calls to dict.keys() (#1243) > Clean up LGTM alerts (#1239) > Add 'requests' as install dependency in setup.py (#1240) > Convert to Python 3 (#1128) > Fix mock SonicV2Connector in python3: use decode_responses mode so caller code will be the same as python2 (#1238) > [tests] Do not trim from PATH if we did not append to it; Clean up/fix shebangs in scripts (#1233) > Updates to bgp config and show commands with BGP_INTERNAL_NEIGHBOR table (#1224) > [cli]: NAT show commands newline issue after migrated to Python3 (#1204) > [doc]: Update Command-Reference.md (#1231) > Added 'import sys' in feature.py file (#1232) * src/sonic-py-swsssdk 9d9f0c6...1664be9 (2): > Fix: no need to decode() after redis client scan, so it will work for both python2 and python3 (#96) > FieldValueMap `contains`(`in`) will also work when migrated to libswsscommon(C++ with SWIG wrapper) (#94) - Also fix Python 3-related issues: - Use integer (floor) division in config_samples.py (sonic-config-engine) - Replace print statement with print function in eeprom.py plugin for x86_64-kvm_x86_64-r0 platform - Update all platform plugins to be compatible with both Python 2 and Python 3 - Remove shebangs from plugins files which are not intended to be executable - Replace tabs with spaces in Python plugin files and fix alignment, because Python 3 is more strict - Remove trailing whitespace from plugins files
438 lines
15 KiB
Python
438 lines
15 KiB
Python
#!/usr/bin/env python3
|
|
#
|
|
# Name: juniper_qfx5200_eepromconv.py version: 1.0
|
|
#
|
|
# Description: This file contains the code to store the contents of Main Board EEPROM and CPU Board EEPROM in file
|
|
#
|
|
# Copyright (c) 2020, Juniper Networks, Inc.
|
|
# All rights reserved.
|
|
#
|
|
# Notice and Disclaimer: This code is licensed to you under the GNU General
|
|
# Public License as published by the Free Software Foundation, version 3 or
|
|
# any later version. This code is not an official Juniper product. You can
|
|
# obtain a copy of the License at <https://www.gnu.org/licenses/>
|
|
#
|
|
# OSS License:
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program 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 General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
#
|
|
# Third-Party Code: This code may depend on other components under separate
|
|
# copyright notice and license terms. Your use of the source code for those
|
|
# components is subject to the terms and conditions of the respective license
|
|
# as noted in the Third-Party source code file.
|
|
|
|
import binascii
|
|
import os
|
|
import sys
|
|
from sonic_eeprom import eeprom_tlvinfo
|
|
|
|
if sys.version_info[0] < 3:
|
|
import commands
|
|
else:
|
|
import subprocess as commands
|
|
|
|
|
|
def fantype_detect():
|
|
|
|
refpgaTMC_path = "/sys/devices/pci0000:00/0000:00:1c.0/0000:0f:00.0/refpga-tmc.15"
|
|
|
|
AFO = "1"
|
|
AFI = "0"
|
|
|
|
# default fan type is AFO
|
|
default_fantype = "0"
|
|
|
|
for filename in os.listdir(refpgaTMC_path):
|
|
if filename.endswith('_type'):
|
|
fantype_path = os.path.join(refpgaTMC_path, filename)
|
|
cat_string = "cat "
|
|
fantype_string = cat_string + fantype_path
|
|
status, fan_type = commands.getstatusoutput(fantype_string)
|
|
if ((fan_type == AFO) or (fan_type == AFI)):
|
|
return fan_type
|
|
else:
|
|
pass
|
|
|
|
return default_fantype
|
|
|
|
|
|
def main():
|
|
AFO_value = "1"
|
|
|
|
eeprom_qfx5200 = Eeprom()
|
|
|
|
fan_type = fantype_detect()
|
|
|
|
# creating the "/var/run/eeprom" file and storing values of CPU board EEPROM and MAIN Board EEPROM in this file.
|
|
eeprom_file = open("/var/run/eeprom", "a+")
|
|
eeprom_file.write("\n")
|
|
if fan_type == AFO_value:
|
|
eeprom_file.write("Fan Type=AFO\r\n")
|
|
else:
|
|
eeprom_file.write("Fan Type=AFI\r\n")
|
|
|
|
eeprom_file.write("\n")
|
|
|
|
# Write the contents of CPU Board EEPROM to file
|
|
eeprom_file.write("CPU board eeprom (0x51)\r\n")
|
|
eeprom_file.write("===============================\r\n")
|
|
eeprom_file.write("Product Name=%s\r\n" % eeprom_qfx5200.modelstr())
|
|
eeprom_file.write("Part Number=%s\r\n" % eeprom_qfx5200.part_number_str())
|
|
eeprom_file.write("Serial Number=%s\r\n" % eeprom_qfx5200.serial_number_str())
|
|
eeprom_file.write("MAC Address=%s\r\n" % eeprom_qfx5200.base_mac_address())
|
|
eeprom_file.write("Manufacture Date=%s\r\n" % eeprom_qfx5200.manuDate_str())
|
|
eeprom_file.write("Platform Name=%s\r\n" % eeprom_qfx5200.platform_str())
|
|
eeprom_file.write("Number of MAC Addresses=%s\r\n" % eeprom_qfx5200.MACsize_str())
|
|
eeprom_file.write("Vendor Name=%s\r\n" % eeprom_qfx5200.vendor_name_str())
|
|
eeprom_file.write("Manufacture Name=%s\r\n" % eeprom_qfx5200.manufacture_name_str())
|
|
|
|
eeprom_dict = eeprom_qfx5200.system_eeprom_info()
|
|
key = '0x29'
|
|
if key in list(eeprom_dict.keys()):
|
|
onie_version_str = eeprom_dict.get('0x29', None)
|
|
else:
|
|
onie_version_str = "N/A"
|
|
eeprom_file.write("ONIE Version=%s\r\n" % onie_version_str)
|
|
|
|
vendor_value_formatted, vendor_value_hexvalue = eeprom_qfx5200.vendor_ext_str()
|
|
|
|
eeprom_hex = '/etc/init.d/eeprom_qfx5200_hex'
|
|
|
|
with open(eeprom_hex, 'wb+') as Hexfile:
|
|
Hexfile.write(vendor_value_hexvalue)
|
|
|
|
# Assembly ID
|
|
ASMID_str = "0D83"
|
|
with open(eeprom_hex, 'rb+') as AsmID_Hexfile:
|
|
AsmID_Hexfile.seek(24, 0)
|
|
AsmID_Hexfile.write(ASMID_str)
|
|
AsmID_Hexfile.seek(0, 0)
|
|
vendorext_read = AsmID_Hexfile.read(58)
|
|
vendorext = ""
|
|
vendorext += "0x" + vendorext_read[0:2]
|
|
for i in range(2, 58, 2):
|
|
vendorext += " 0x" + vendorext_read[i:i+2]
|
|
eeprom_file.write("Vendor Extension=%s\r\n" % str(vendorext))
|
|
|
|
with open(eeprom_hex, 'rb') as eeprom_hexfile:
|
|
eeprom_hexfile.seek(0, 0)
|
|
IANA_position_read = eeprom_hexfile.read(8)
|
|
IANA_write = binascii.unhexlify(IANA_position_read)
|
|
eeprom_file.write("\t")
|
|
eeprom_file.write("IANA=0x%s\r\n" % IANA_write)
|
|
|
|
eeprom_hexfile.seek(8, 0)
|
|
AssemblyPartRev_position_read = eeprom_hexfile.read(16)
|
|
AssemblyPartRev_write = binascii.unhexlify(AssemblyPartRev_position_read)
|
|
eeprom_file.write("\t")
|
|
eeprom_file.write("Assembly Part Number Revision=0x%s\r\n" % AssemblyPartRev_write)
|
|
|
|
eeprom_hexfile.seek(24, 0)
|
|
AssemblyID_write = eeprom_hexfile.read(4)
|
|
eeprom_file.write("\t")
|
|
eeprom_file.write("Assembly ID=0x%s\r\n" % AssemblyID_write)
|
|
|
|
eeprom_hexfile.seek(28, 0)
|
|
HWMajorRev_write = eeprom_hexfile.read(2)
|
|
eeprom_file.write("\t")
|
|
eeprom_file.write("HW Major Revision=0x%s\r\n" % HWMajorRev_write)
|
|
|
|
eeprom_hexfile.seek(30, 0)
|
|
HWMinorRev_write = eeprom_hexfile.read(2)
|
|
eeprom_file.write("\t")
|
|
eeprom_file.write("HW Minor Revision=0x%s\r\n" % HWMinorRev_write)
|
|
|
|
eeprom_hexfile.seek(32, 0)
|
|
Deviation_write = eeprom_hexfile.read(10)
|
|
eeprom_file.write("\t")
|
|
eeprom_file.write("Deviation=0x%s\r\n" % Deviation_write)
|
|
|
|
eeprom_hexfile.seek(52, 0)
|
|
JEDC_write = eeprom_hexfile.read(4)
|
|
eeprom_file.write("\t")
|
|
eeprom_file.write("JEDC=0x%s\r\n" % JEDC_write)
|
|
|
|
eeprom_hexfile.seek(56, 0)
|
|
EEPROM_version_write = eeprom_hexfile.read(2)
|
|
eeprom_file.write("\t")
|
|
eeprom_file.write("EEPROM version=0x%s\r\n" % EEPROM_version_write)
|
|
|
|
crc_str = eeprom_dict.get('0xFE', None)
|
|
eeprom_file.write("CRC=%s\r\n" % crc_str)
|
|
|
|
eeprom_file.write("\n")
|
|
eeprom_file.write("\n")
|
|
eeprom_file.write("Main board eeprom (0x57)\r\n")
|
|
eeprom_file.write("===============================\r\n")
|
|
|
|
MainEepromCreate = 'sudo echo 24c02 0x57 > /sys/bus/i2c/devices/i2c-0/new_device'
|
|
# Write the contents of Main Board EEPROM to file
|
|
try:
|
|
os.system(MainEepromCreate)
|
|
except OSError:
|
|
print('Error: Execution of "%s" failed', MainEepromCreate)
|
|
return False
|
|
|
|
MainEepromFileCmd = 'cat /sys/bus/i2c/devices/i2c-0/0-0057/eeprom > /etc/init.d/MainEeprom_qfx5200_ascii'
|
|
try:
|
|
os.system(MainEepromFileCmd)
|
|
except OSError:
|
|
print('Error: Execution of "%s" failed', MainEepromFileCmd)
|
|
return False
|
|
|
|
maineeprom_ascii = '/etc/init.d/MainEeprom_qfx5200_ascii'
|
|
|
|
# Read file contents in Hex format
|
|
with open(maineeprom_ascii, 'rb') as Hexformat:
|
|
content = Hexformat.read()
|
|
|
|
Hexformatoutput = binascii.hexlify(content)
|
|
eeprom_hex = '/etc/init.d/MainEeprom_qfx5200_hex'
|
|
# Write contents of CPU EEPROM to new file in hexa format
|
|
with open(eeprom_hex, 'wb+') as Hexfile:
|
|
Hexfile.write(Hexformatoutput)
|
|
|
|
with open(eeprom_hex, 'rb') as eeprom_hexfile:
|
|
eeprom_hexfile.seek(8, 0)
|
|
AssemblyID_read = eeprom_hexfile.read(4)
|
|
eeprom_file.write("Assembly ID=0x%s\r\n" % AssemblyID_read)
|
|
|
|
eeprom_hexfile.seek(12, 0)
|
|
MajorHWRev_read = eeprom_hexfile.read(2)
|
|
eeprom_file.write("Assembly Major Revision=0x%s\r\n" % str(MajorHWRev_read))
|
|
|
|
eeprom_hexfile.seek(14, 0)
|
|
MinorHWRev_read = eeprom_hexfile.read(2)
|
|
eeprom_file.write("Assembly Minor Revision=0x%s\r\n" % str(MinorHWRev_read))
|
|
|
|
eeprom_hexfile.seek(24, 0)
|
|
AssemblyPNRev_read = eeprom_hexfile.read(16)
|
|
AssemblyPNRev_write = binascii.unhexlify(AssemblyPNRev_read)
|
|
eeprom_file.write("Assembly Part Number Revision=0x%s\r\n" % str(AssemblyPNRev_write))
|
|
|
|
eeprom_hexfile.seek(40, 0)
|
|
AssemblyPN_read = eeprom_hexfile.read(24)
|
|
AssemblyPN_write = binascii.unhexlify(AssemblyPN_read)
|
|
eeprom_file.write("Assembly Part Number=%s\r\n" % str(AssemblyPN_write))
|
|
|
|
eeprom_hexfile.seek(64, 0)
|
|
AssemblySN_read = eeprom_hexfile.read(24)
|
|
AssemblySN_write = binascii.unhexlify(AssemblySN_read)
|
|
eeprom_file.write("Assembly Serial Number=%s\r\n" % str(AssemblySN_write))
|
|
|
|
eeprom_hexfile.seek(90, 0)
|
|
AssemblyMFGDate_read = eeprom_hexfile.read(8)
|
|
eeprom_file.write("Manufacture Date=%s\r\n" % str(AssemblyMFGDate_read))
|
|
|
|
eeprom_hexfile.seek(138, 0)
|
|
CLEICode_read = eeprom_hexfile.read(20)
|
|
CLEI_name = binascii.unhexlify(CLEICode_read)
|
|
eeprom_file.write("CLEI Code=%s\r\n" % str(CLEI_name))
|
|
|
|
eeprom_hexfile.seek(158, 0)
|
|
FRUModelNumber_read = eeprom_hexfile.read(46)
|
|
FRUModelNumber_write = binascii.unhexlify(FRUModelNumber_read)
|
|
eeprom_file.write("FRU Model Number=%s\r\n" % str(FRUModelNumber_write))
|
|
|
|
eeprom_hexfile.seek(204, 0)
|
|
FRUModelMajorNumber_read = eeprom_hexfile.read(2)
|
|
eeprom_file.write("FRU Model Major Number=0x%s\r\n" % str(FRUModelMajorNumber_read))
|
|
|
|
eeprom_hexfile.seek(206, 0)
|
|
FRUModelMinorNumber_read = eeprom_hexfile.read(4)
|
|
eeprom_file.write("FRU Model Minor Number=0x%s\r\n" % str(FRUModelMinorNumber_read))
|
|
|
|
eeprom_hexfile.seek(210, 0)
|
|
Deviation_read = eeprom_hexfile.read(10)
|
|
eeprom_file.write("Deviation=0x%s\r\n" % str(Deviation_read))
|
|
|
|
eeprom_hexfile.seek(232, 0)
|
|
SerialNumber_read = eeprom_hexfile.read(24)
|
|
SerialNumber_write = binascii.unhexlify(SerialNumber_read)
|
|
eeprom_file.write("Chassis Serial Number=%s\r\n" % str(SerialNumber_write))
|
|
eeprom_file.close()
|
|
return True
|
|
|
|
|
|
class Eeprom(eeprom_tlvinfo.TlvInfoDecoder):
|
|
def __init__(self):
|
|
self.__eeprom_path = "/sys/class/i2c-adapter/i2c-0/0-0051/eeprom"
|
|
super(Eeprom, self).__init__(self.__eeprom_path, 0, '', True)
|
|
self.__eeprom_tlv_dict = dict()
|
|
try:
|
|
self.__eeprom_data = self.read_eeprom()
|
|
except:
|
|
self.__eeprom_data = "N/A"
|
|
raise RuntimeError("Eeprom is not Programmed")
|
|
else:
|
|
eeprom = self.__eeprom_data
|
|
|
|
if not self.is_valid_tlvinfo_header(eeprom):
|
|
return
|
|
|
|
total_length = (ord(eeprom[9]) << 8) | ord(eeprom[10])
|
|
tlv_index = self._TLV_INFO_HDR_LEN
|
|
tlv_end = self._TLV_INFO_HDR_LEN + total_length
|
|
|
|
while (tlv_index + 2) < len(eeprom) and tlv_index < tlv_end:
|
|
if not self.is_valid_tlv(eeprom[tlv_index:]):
|
|
break
|
|
|
|
tlv = eeprom[tlv_index:tlv_index + 2
|
|
+ ord(eeprom[tlv_index + 1])]
|
|
code = "0x%02X" % (ord(tlv[0]))
|
|
|
|
if ord(tlv[0]) == self._TLV_CODE_VENDOR_EXT:
|
|
value = str((ord(tlv[2]) << 24) | (ord(tlv[3]) << 16) |
|
|
(ord(tlv[4]) << 8) | ord(tlv[5]))
|
|
value += str(tlv[6:6 + ord(tlv[1])])
|
|
else:
|
|
name, value = self.decoder(None, tlv)
|
|
|
|
self.__eeprom_tlv_dict[code] = value
|
|
if ord(eeprom[tlv_index]) == self._TLV_CODE_CRC_32:
|
|
break
|
|
|
|
tlv_index += ord(eeprom[tlv_index+1]) + 2
|
|
|
|
def serial_number_str(self):
|
|
(is_valid, results) = self.get_tlv_field(
|
|
self.__eeprom_data, self._TLV_CODE_SERIAL_NUMBER)
|
|
if not is_valid:
|
|
return "N/A"
|
|
return results[2]
|
|
|
|
def base_mac_address(self):
|
|
(is_valid, t) = self.get_tlv_field(
|
|
self.__eeprom_data, self._TLV_CODE_MAC_BASE)
|
|
if not is_valid or t[1] != 6:
|
|
return super(eeprom_tlvinfo.TlvInfoDecoder, self).switchaddrstr(self.__eeprom_data)
|
|
|
|
return ":".join([binascii.b2a_hex(T) for T in t[2]])
|
|
|
|
def modelstr(self):
|
|
(is_valid, results) = self.get_tlv_field(
|
|
self.__eeprom_data, self._TLV_CODE_PRODUCT_NAME)
|
|
if not is_valid:
|
|
return "N/A"
|
|
|
|
return results[2]
|
|
|
|
def part_number_str(self):
|
|
(is_valid, results) = self.get_tlv_field(
|
|
self.__eeprom_data, self._TLV_CODE_PART_NUMBER)
|
|
if not is_valid:
|
|
return "N/A"
|
|
|
|
return results[2]
|
|
|
|
def serial_tag_str(self):
|
|
(is_valid, results) = self.get_tlv_field(
|
|
self.__eeprom_data, self._TLV_CODE_SERVICE_TAG)
|
|
if not is_valid:
|
|
return "N/A"
|
|
|
|
return results[2]
|
|
|
|
def revision_str(self):
|
|
(is_valid, results) = self.get_tlv_field(
|
|
self.__eeprom_data, self._TLV_CODE_DEVICE_VERSION)
|
|
if not is_valid:
|
|
return "N/A"
|
|
|
|
return results[2]
|
|
|
|
def manuDate_str(self):
|
|
(is_valid, results) = self.get_tlv_field(
|
|
self.__eeprom_data, self._TLV_CODE_MANUF_DATE)
|
|
if not is_valid:
|
|
return "N/A"
|
|
|
|
return results[2]
|
|
|
|
def platform_str(self):
|
|
(is_valid, results) = self.get_tlv_field(
|
|
self.__eeprom_data, self._TLV_CODE_PLATFORM_NAME)
|
|
if not is_valid:
|
|
return "N/A"
|
|
|
|
return results[2]
|
|
|
|
def MACsize_str(self):
|
|
(is_valid, t) = self.get_tlv_field(self.__eeprom_data, self._TLV_CODE_MAC_SIZE)
|
|
|
|
if not is_valid:
|
|
return "N/A"
|
|
|
|
return str((ord(t[2][0]) << 8) | ord(t[2][1]))
|
|
|
|
def vendor_name_str(self):
|
|
(is_valid, results) = self.get_tlv_field(
|
|
self.__eeprom_data, self._TLV_CODE_VENDOR_NAME)
|
|
if not is_valid:
|
|
return "N/A"
|
|
|
|
return results[2]
|
|
|
|
def manufacture_name_str(self):
|
|
(is_valid, results) = self.get_tlv_field(
|
|
self.__eeprom_data, self._TLV_CODE_MANUF_NAME)
|
|
if not is_valid:
|
|
return "N/A"
|
|
|
|
return results[2]
|
|
|
|
def onie_version_str(self):
|
|
value = ""
|
|
(is_valid, results) = self.get_tlv_field(
|
|
self.__eeprom_data, self._TLV_CODE_ONIE_VERSION)
|
|
if not is_valid:
|
|
return "N/A"
|
|
|
|
for c in results[2:2 + ord(results[1])]:
|
|
value += "0x%02X " % (ord(c),)
|
|
|
|
return value
|
|
|
|
def vendor_ext_str(self):
|
|
|
|
(is_valid, results) = self.get_tlv_field(
|
|
self.__eeprom_data, self._TLV_CODE_VENDOR_EXT)
|
|
|
|
if not is_valid:
|
|
return "N/A"
|
|
|
|
vendor_value_formatted = ''.join([" 0x" + "%02X " % ord(x) for x in results[2]]).strip()
|
|
vendor_value_hexvalue = ''.join(["%02X" % ord(x) for x in results[2]]).strip()
|
|
|
|
return vendor_value_formatted, vendor_value_hexvalue
|
|
|
|
def crc_str(self):
|
|
(is_valid, results) = self.get_tlv_field(
|
|
self.__eeprom_data, self._TLV_CODE_CRC_32)
|
|
if not is_valid:
|
|
return "N/A"
|
|
|
|
def system_eeprom_info(self):
|
|
"""
|
|
Returns a dictionary, where keys are the type code defined in
|
|
ONIE EEPROM format and values are their corresponding values
|
|
found in the system EEPROM.
|
|
"""
|
|
return self.__eeprom_tlv_dict
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|