0e0772596e
Signed-off-by: pettershao-ragilenetworks pettershao@ragilenetworks.com What I did it Add new platform x86_64-ragile_ra-b6510-32c-r0 (Trident 3) ASIC Vendor: Broadcom Switch ASIC: Trident 3 Port Config: 32x100G Add new platform x86_64-ragile_ra-b6920-4s-r0 (Tomahawk 3) ASIC Vendor: Broadcom Switch ASIC: Tomahawk 3 Port Config: 128x100G -How I did it Provide device and platform related files. -How to verify it show platform fan show platform ssdhealth show platform psustatus show platform summary show platform syseeprom show platform temperature show interface status
2102 lines
58 KiB
Python
Executable File
2102 lines
58 KiB
Python
Executable File
# -*- coding: UTF-8 -*-
|
||
# -------------------------------------------------------------------------
|
||
# Name: ragileutil
|
||
# Purpose: common configuration and api
|
||
#
|
||
# Author: rd
|
||
#
|
||
# Created: 02/07/2018
|
||
# Copyright: (c) rd 2018
|
||
# -------------------------------------------------------------------------
|
||
import sys
|
||
|
||
if sys.version_info >= (3, 0):
|
||
import subprocess as commands
|
||
else:
|
||
import commands
|
||
import os
|
||
import re
|
||
import syslog
|
||
import time
|
||
import binascii
|
||
import tty
|
||
import termios
|
||
import threading
|
||
import click
|
||
import mmap
|
||
from ragileconfig import (
|
||
rg_eeprom,
|
||
FRULISTS,
|
||
MAC_DEFAULT_PARAM,
|
||
MAC_AVS_PARAM,
|
||
FANS_DEF,
|
||
FAN_PROTECT,
|
||
E2_LOC,
|
||
E2_PROTECT,
|
||
RAGILE_SERVICE_TAG,
|
||
RAGILE_DIAG_VERSION,
|
||
STARTMODULE,
|
||
RAGILE_CARDID,
|
||
RAGILE_PRODUCTNAME,
|
||
RAGILE_PART_NUMBER,
|
||
RAGILE_LABEL_REVISION,
|
||
RAGILE_MAC_SIZE,
|
||
RAGILE_MANUF_NAME,
|
||
RAGILE_MANUF_COUNTRY,
|
||
RAGILE_VENDOR_NAME,
|
||
MAILBOX_DIR,
|
||
)
|
||
|
||
try:
|
||
from eepromutil.fru import ipmifru
|
||
|
||
except Exception or SystemExit:
|
||
pass
|
||
|
||
import logging.handlers
|
||
import shutil
|
||
import gzip
|
||
import glob
|
||
|
||
__all__ = [
|
||
"MENUID",
|
||
"MENUPARENT",
|
||
"MENUVALUE",
|
||
"CHILDID",
|
||
"MENUITEMNAME",
|
||
"MENUITEMDEAL",
|
||
"GOBACK",
|
||
"GOQUIT",
|
||
"file_name",
|
||
"CRITICAL",
|
||
"FATAL",
|
||
"ERROR",
|
||
"WARNING",
|
||
"WARN",
|
||
"INFO",
|
||
"DEBUG",
|
||
"NOTSET",
|
||
"levelNames",
|
||
"TLV_INFO_ID_STRING",
|
||
"TLV_INFO_VERSION",
|
||
"TLV_INFO_LENGTH",
|
||
"TLV_INFO_LENGTH_VALUE",
|
||
"TLV_CODE_PRODUCT_NAME",
|
||
"TLV_CODE_PART_NUMBER",
|
||
"TLV_CODE_SERIAL_NUMBER",
|
||
"TLV_CODE_MAC_BASE",
|
||
"TLV_CODE_MANUF_DATE",
|
||
"TLV_CODE_DEVICE_VERSION",
|
||
"TLV_CODE_LABEL_REVISION",
|
||
"TLV_CODE_PLATFORM_NAME",
|
||
"TLV_CODE_ONIE_VERSION",
|
||
"TLV_CODE_MAC_SIZE",
|
||
"TLV_CODE_MANUF_NAME",
|
||
"TLV_CODE_MANUF_COUNTRY",
|
||
"TLV_CODE_VENDOR_NAME",
|
||
"TLV_CODE_DIAG_VERSION",
|
||
"TLV_CODE_SERVICE_TAG",
|
||
"TLV_CODE_VENDOR_EXT",
|
||
"TLV_CODE_CRC_32",
|
||
"_TLV_DISPLAY_VENDOR_EXT",
|
||
"TLV_CODE_RJ_CARID",
|
||
"_TLV_INFO_HDR_LEN",
|
||
"SYSLOG_IDENTIFIER",
|
||
"log_info",
|
||
"log_debug",
|
||
"log_warning",
|
||
"log_error",
|
||
"CompressedRotatingFileHandler",
|
||
"SETMACException",
|
||
"checkinput",
|
||
"checkinputproduct",
|
||
"getInputSetmac",
|
||
"fan_tlv",
|
||
"AVSUTIL",
|
||
"I2CUTIL",
|
||
"BMC",
|
||
"getSdkReg",
|
||
"getfilevalue",
|
||
"get_sysfs_value",
|
||
"write_sysfs_value",
|
||
"RJPRINTERR",
|
||
"strtoint",
|
||
"inttostr",
|
||
"str_to_hex",
|
||
"hex_to_str",
|
||
"str_to_bin",
|
||
"bin_to_str",
|
||
"get_mac_temp",
|
||
"get_mac_temp_sysfs",
|
||
"restartDockerService",
|
||
"wait_dhcp",
|
||
"wait_sdk",
|
||
"wait_docker",
|
||
"getTLV_BODY",
|
||
"_crc32",
|
||
"printvalue",
|
||
"generate_value",
|
||
"getsyseeprombyId",
|
||
"fac_init_cardidcheck",
|
||
"isValidMac",
|
||
"util_setmac",
|
||
"getInputCheck",
|
||
"getrawch",
|
||
"upper_input",
|
||
"changeTypeValue",
|
||
"astrcmp",
|
||
"generate_ext",
|
||
"rgi2cget",
|
||
"rgi2cset",
|
||
"rgpcird",
|
||
"rgpciwr",
|
||
"rgsysset",
|
||
"rgi2cget_word",
|
||
"rgi2cset_word",
|
||
"fan_setmac",
|
||
"checkfansninput",
|
||
"checkfanhwinput",
|
||
"util_show_fanse2",
|
||
"get_fane2_sysfs",
|
||
"util_show_fane2",
|
||
"getPid",
|
||
"fac_fans_setmac_tlv",
|
||
"fac_fan_setmac_fru",
|
||
"fac_fans_setmac",
|
||
"fac_fan_setmac",
|
||
"writeToEEprom",
|
||
"get_local_eth0_mac",
|
||
"getonieversion",
|
||
"createbmcMac",
|
||
"fac_board_setmac",
|
||
"ipmi_set_mac",
|
||
"getInputValue",
|
||
"bmc_setmac",
|
||
"closeProtocol",
|
||
"checkSdkMem",
|
||
"getch",
|
||
"get_raw_input",
|
||
"getsysvalue",
|
||
"get_pmc_register",
|
||
"decoder",
|
||
"decode_eeprom",
|
||
"get_sys_eeprom",
|
||
"getCardId",
|
||
"getsysmeminfo",
|
||
"getsysmeminfo_detail",
|
||
"getDmiSysByType",
|
||
"gethwsys",
|
||
"getsysbios",
|
||
"searchDirByName",
|
||
"getUsbLocation",
|
||
"getusbinfo",
|
||
"get_cpu_info",
|
||
"get_version_config_info",
|
||
"io_rd",
|
||
"io_wr",
|
||
]
|
||
|
||
MENUID = "menuid"
|
||
MENUPARENT = "parentid"
|
||
MENUVALUE = "value"
|
||
CHILDID = "childid"
|
||
MENUITEMNAME = "name"
|
||
MENUITEMDEAL = "deal"
|
||
GOBACK = "goBack"
|
||
GOQUIT = "quit"
|
||
|
||
file_name = "/etc/init.d/opennsl-modules-3.16.0-5-amd64"
|
||
##########################################################################
|
||
# ERROR LOG LEVEL
|
||
##########################################################################
|
||
CRITICAL = 50
|
||
FATAL = CRITICAL
|
||
ERROR = 40
|
||
WARNING = 30
|
||
WARN = WARNING
|
||
INFO = 20
|
||
DEBUG = 10
|
||
NOTSET = 0
|
||
|
||
levelNames = {
|
||
CRITICAL: "CRITICAL",
|
||
ERROR: "ERROR",
|
||
WARNING: "WARNING",
|
||
INFO: "INFO",
|
||
DEBUG: "DEBUG",
|
||
NOTSET: "NOTSET",
|
||
"CRITICAL": CRITICAL,
|
||
"ERROR": ERROR,
|
||
"WARN": WARNING,
|
||
"WARNING": WARNING,
|
||
"INFO": INFO,
|
||
"DEBUG": DEBUG,
|
||
"NOTSET": NOTSET,
|
||
}
|
||
|
||
TLV_INFO_ID_STRING = "TlvInfo\x00"
|
||
TLV_INFO_VERSION = 0x01
|
||
TLV_INFO_LENGTH = 0x00
|
||
TLV_INFO_LENGTH_VALUE = 0xBA
|
||
|
||
##########################################################################
|
||
# eeprom info
|
||
##########################################################################
|
||
TLV_CODE_PRODUCT_NAME = 0x21
|
||
TLV_CODE_PART_NUMBER = 0x22
|
||
TLV_CODE_SERIAL_NUMBER = 0x23
|
||
TLV_CODE_MAC_BASE = 0x24
|
||
TLV_CODE_MANUF_DATE = 0x25
|
||
TLV_CODE_DEVICE_VERSION = 0x26
|
||
TLV_CODE_LABEL_REVISION = 0x27
|
||
TLV_CODE_PLATFORM_NAME = 0x28
|
||
TLV_CODE_ONIE_VERSION = 0x29
|
||
TLV_CODE_MAC_SIZE = 0x2A
|
||
TLV_CODE_MANUF_NAME = 0x2B
|
||
TLV_CODE_MANUF_COUNTRY = 0x2C
|
||
TLV_CODE_VENDOR_NAME = 0x2D
|
||
TLV_CODE_DIAG_VERSION = 0x2E
|
||
TLV_CODE_SERVICE_TAG = 0x2F
|
||
TLV_CODE_VENDOR_EXT = 0xFD
|
||
TLV_CODE_CRC_32 = 0xFE
|
||
_TLV_DISPLAY_VENDOR_EXT = 1
|
||
TLV_CODE_RJ_CARID = 0x01
|
||
_TLV_INFO_HDR_LEN = 11
|
||
|
||
|
||
SYSLOG_IDENTIFIER = "UTILTOOL"
|
||
|
||
# ========================== Syslog wrappers ==========================
|
||
|
||
|
||
def log_info(msg, also_print_to_console=False):
|
||
syslog.openlog(SYSLOG_IDENTIFIER)
|
||
syslog.syslog(syslog.LOG_INFO, msg)
|
||
syslog.closelog()
|
||
|
||
if also_print_to_console:
|
||
click.echo(msg)
|
||
|
||
|
||
def log_debug(msg, also_print_to_console=False):
|
||
try:
|
||
syslog.openlog(SYSLOG_IDENTIFIER)
|
||
syslog.syslog(syslog.LOG_DEBUG, msg)
|
||
syslog.closelog()
|
||
|
||
if also_print_to_console:
|
||
click.echo(msg)
|
||
except Exception as e:
|
||
pass
|
||
|
||
|
||
def log_warning(msg, also_print_to_console=False):
|
||
syslog.openlog(SYSLOG_IDENTIFIER)
|
||
syslog.syslog(syslog.LOG_WARNING, msg)
|
||
syslog.closelog()
|
||
|
||
if also_print_to_console:
|
||
click.echo(msg)
|
||
|
||
|
||
def log_error(msg, also_print_to_console=False):
|
||
syslog.openlog(SYSLOG_IDENTIFIER)
|
||
syslog.syslog(syslog.LOG_ERR, msg)
|
||
syslog.closelog()
|
||
|
||
if also_print_to_console:
|
||
click.echo(msg)
|
||
|
||
|
||
class CompressedRotatingFileHandler(logging.handlers.RotatingFileHandler):
|
||
def doRollover(self):
|
||
"""
|
||
Do a rollover, as described in __init__().
|
||
"""
|
||
if self.stream:
|
||
self.stream.close()
|
||
self.stream = None
|
||
if self.backupCount > 0:
|
||
for i in range(self.backupCount - 1, 0, -1):
|
||
sfn = "%s.%d.gz" % (self.baseFilename, i)
|
||
dfn = "%s.%d.gz" % (self.baseFilename, i + 1)
|
||
if os.path.exists(sfn):
|
||
if os.path.exists(dfn):
|
||
os.remove(dfn)
|
||
os.rename(sfn, dfn)
|
||
dfn = self.baseFilename + ".1.gz"
|
||
if os.path.exists(dfn):
|
||
os.remove(dfn)
|
||
# These two lines below are the only new lines. I commented out the os.rename(self.baseFilename, dfn) and
|
||
# replaced it with these two lines.
|
||
with open(self.baseFilename, "rb") as f_in, gzip.open(dfn, "wb") as f_out:
|
||
shutil.copyfileobj(f_in, f_out)
|
||
self.mode = "w"
|
||
self.stream = self._open()
|
||
|
||
|
||
class SETMACException(Exception):
|
||
def __init__(self, param="ERROR", errno="-1"):
|
||
err = "Setmac fail[%s]: %s" % (errno, param)
|
||
Exception.__init__(self, err)
|
||
self.param = param
|
||
self.errno = errno
|
||
|
||
|
||
def checkinput(b):
|
||
if b.isdigit() == False:
|
||
raise Exception("Ivalid Number")
|
||
if int(b) > 0xFF or int(b) < 0:
|
||
raise Exception("Out of area")
|
||
|
||
|
||
def checkinputproduct(b):
|
||
if b.isalnum() == False:
|
||
raise Exception("Invalid string")
|
||
|
||
|
||
def getInputSetmac(val):
|
||
bia = val.boardInfoArea
|
||
pia = val.productInfoArea
|
||
if bia != None:
|
||
a = raw_input("[Board Card]Product Serial Number:")
|
||
if len(a) != 13:
|
||
raise Exception("Invalid Serial Number length")
|
||
checkinputproduct(a)
|
||
bia.boardSerialNumber = a
|
||
b = raw_input("[Board Card]Product Version:(from 1-255)")
|
||
checkinput(b)
|
||
b = "%0x" % int(b)
|
||
bia.boardextra1 = b.upper()
|
||
if pia != None:
|
||
a = raw_input("[Product Area]Product Serial Number:")
|
||
if len(a) != 13:
|
||
raise Exception("Invalid Serial Number")
|
||
checkinputproduct(a)
|
||
pia.productSerialNumber = a
|
||
b = raw_input("[Product Area]Product Version:(from 1-255)")
|
||
checkinput(b)
|
||
b = "%0x" % int(b)
|
||
pia.productVersion = b.upper()
|
||
return val
|
||
|
||
|
||
class fan_tlv(object):
|
||
VERSION = 0x01 # E2PROM Version，start from 0x01
|
||
FLAG = 0x7E # New E2PROM version flag is 0x7E
|
||
HW_VER = 0x01 # compose by master version and fixed version
|
||
TYPE = 0xF1 # hw type defination
|
||
TLV_LEN = 00 # data length (16bit)
|
||
_FAN_TLV_HDR_LEN = 6
|
||
_FAN_TLV_CRC_LEN = 2
|
||
|
||
_FAN_TLV_TYPE_NAME = 0x02
|
||
_FAN_TLV_TYPE_SN = 0x03
|
||
_FAN_TLV_TYPE_HW_INFO = 0x05
|
||
_FAN_TLV_TYPE_DEV_TYPE = 0x06
|
||
|
||
_fandecodetime = 0
|
||
|
||
@property
|
||
def dstatus(self):
|
||
return self._dstatus
|
||
|
||
@property
|
||
def typename(self):
|
||
return self._typename
|
||
|
||
@property
|
||
def typesn(self):
|
||
return self._typesn
|
||
|
||
@property
|
||
def typehwinfo(self):
|
||
return self._typehwinfo
|
||
|
||
@property
|
||
def typedevtype(self):
|
||
return self._typedevtype
|
||
|
||
@property
|
||
def fanbus(self):
|
||
return self._fanbus
|
||
|
||
@property
|
||
def fanloc(self):
|
||
return self._fanloc
|
||
|
||
@property
|
||
def fandecodetime(self):
|
||
return self._fandecodetime
|
||
|
||
def __init__(self):
|
||
self._typename = ""
|
||
self._typesn = ""
|
||
self._typehwinfo = ""
|
||
self._typedevtype = ""
|
||
self._dstatus = 0
|
||
|
||
def strtoarr(self, str):
|
||
s = []
|
||
if str is not None:
|
||
for index in range(len(str)):
|
||
s.append(str[index])
|
||
return s
|
||
|
||
def generate_fan_value(self):
|
||
bin_buffer = [chr(0xFF)] * 256
|
||
bin_buffer[0] = chr(self.VERSION)
|
||
bin_buffer[1] = chr(self.FLAG)
|
||
bin_buffer[2] = chr(self.HW_VER)
|
||
bin_buffer[3] = chr(self.TYPE)
|
||
|
||
temp_t = "%08x" % self.typedevtype # handle devtype first
|
||
typedevtype_t = hex_to_str(temp_t)
|
||
total_len = (
|
||
len(self.typename)
|
||
+ len(self.typesn)
|
||
+ len(self.typehwinfo)
|
||
+ len(typedevtype_t)
|
||
+ 8
|
||
)
|
||
|
||
bin_buffer[4] = chr(total_len >> 8)
|
||
bin_buffer[5] = chr(total_len & 0x00FF)
|
||
|
||
index_start = 6
|
||
bin_buffer[index_start] = chr(self._FAN_TLV_TYPE_NAME)
|
||
bin_buffer[index_start + 1] = chr(len(self.typename))
|
||
bin_buffer[
|
||
index_start + 2 : index_start + 2 + len(self.typename)
|
||
] = self.strtoarr(self.typename)
|
||
index_start = index_start + 2 + len(self.typename)
|
||
|
||
bin_buffer[index_start] = chr(self._FAN_TLV_TYPE_SN)
|
||
bin_buffer[index_start + 1] = chr(len(self.typesn))
|
||
bin_buffer[
|
||
index_start + 2 : index_start + 2 + len(self.typesn)
|
||
] = self.strtoarr(self.typesn)
|
||
index_start = index_start + 2 + len(self.typesn)
|
||
|
||
bin_buffer[index_start] = chr(self._FAN_TLV_TYPE_HW_INFO)
|
||
bin_buffer[index_start + 1] = chr(len(self.typehwinfo))
|
||
bin_buffer[
|
||
index_start + 2 : index_start + 2 + len(self.typehwinfo)
|
||
] = self.strtoarr(self.typehwinfo)
|
||
index_start = index_start + 2 + len(self.typehwinfo)
|
||
|
||
bin_buffer[index_start] = chr(self._FAN_TLV_TYPE_DEV_TYPE)
|
||
bin_buffer[index_start + 1] = chr(len(typedevtype_t))
|
||
bin_buffer[
|
||
index_start + 2 : index_start + 2 + len(typedevtype_t)
|
||
] = self.strtoarr(typedevtype_t)
|
||
index_start = index_start + 2 + len(typedevtype_t)
|
||
|
||
crcs = fan_tlv.fancrc("".join(bin_buffer[0:index_start])) # check 2bytes
|
||
bin_buffer[index_start] = chr(crcs >> 8)
|
||
bin_buffer[index_start + 1] = chr(crcs & 0x00FF)
|
||
return bin_buffer
|
||
|
||
def decode(self, e2):
|
||
ret = []
|
||
self.VERSION = ord(e2[0])
|
||
self.FLAG = ord(e2[1])
|
||
self.HW_VER = ord(e2[2])
|
||
self.TYPE = ord(e2[3])
|
||
self.TLV_LEN = (ord(e2[4]) << 8) | ord(e2[5])
|
||
|
||
tlv_index = self._FAN_TLV_HDR_LEN
|
||
tlv_end = self._FAN_TLV_HDR_LEN + self.TLV_LEN
|
||
|
||
# check checksum
|
||
if len(e2) < self._FAN_TLV_HDR_LEN + self.TLV_LEN + 2:
|
||
self._dstatus = -2
|
||
return ret
|
||
sumcrc = fan_tlv.fancrc(e2[0 : self._FAN_TLV_HDR_LEN + self.TLV_LEN])
|
||
readcrc = ord(e2[self._FAN_TLV_HDR_LEN + self.TLV_LEN]) << 8 | ord(
|
||
e2[self._FAN_TLV_HDR_LEN + self.TLV_LEN + 1]
|
||
)
|
||
if sumcrc != readcrc:
|
||
self._dstatus = -1
|
||
return ret
|
||
else:
|
||
self._dstatus = 0
|
||
while (tlv_index + 2) < len(e2) and tlv_index < tlv_end:
|
||
s = self.decoder(e2[tlv_index : tlv_index + 2 + ord(e2[tlv_index + 1])])
|
||
tlv_index += ord(e2[tlv_index + 1]) + 2
|
||
ret.append(s)
|
||
|
||
return ret
|
||
|
||
@staticmethod
|
||
def fancrc(t):
|
||
sum = 0
|
||
for index in range(len(t)):
|
||
sum += ord(t[index])
|
||
return sum
|
||
|
||
def decoder(self, t):
|
||
try:
|
||
name = ""
|
||
value = ""
|
||
if ord(t[0]) == self._FAN_TLV_TYPE_NAME:
|
||
name = "Product Name"
|
||
value = str(t[2 : 2 + ord(t[1])])
|
||
self._typename = value
|
||
elif ord(t[0]) == self._FAN_TLV_TYPE_SN:
|
||
name = "serial Number"
|
||
value = str(t[2 : 2 + ord(t[1])])
|
||
self._typesn = value
|
||
elif ord(t[0]) == self._FAN_TLV_TYPE_HW_INFO:
|
||
name = "hardware info"
|
||
value = str(t[2 : 2 + ord(t[1])])
|
||
self._typehwinfo = value
|
||
elif ord(t[0]) == self._FAN_TLV_TYPE_DEV_TYPE:
|
||
name = "dev type"
|
||
value = str(t[2 : 2 + ord(t[1])])
|
||
value = str_to_hex(value)
|
||
self._typedevtype = value
|
||
value = "0x08%x" % value
|
||
except Exception as e:
|
||
print(e)
|
||
return {"name": name, "code": ord(t[0]), "value": value}
|
||
|
||
def __str__(self):
|
||
formatstr = (
|
||
"VERSION : 0x%02x \n"
|
||
" FLAG : 0x%02x \n"
|
||
" HW_VER : 0x%02x \n"
|
||
" TYPE : 0x%02x \n"
|
||
"typename : %s \n"
|
||
"typesn : %s \n"
|
||
"typehwinfo : %s \n"
|
||
)
|
||
return formatstr % (
|
||
self.VERSION,
|
||
self.FLAG,
|
||
self.HW_VER,
|
||
self.TYPE,
|
||
self.typename,
|
||
self.typesn,
|
||
self.typehwinfo,
|
||
)
|
||
|
||
|
||
class AVSUTIL:
|
||
@staticmethod
|
||
def mac_avs_chip(bus, devno, loc, open, close, loop, protectaddr, level, loopaddr):
|
||
# disable protection
|
||
rgi2cset(bus, devno, protectaddr, open)
|
||
rgi2cset(bus, devno, loopaddr, loop)
|
||
rgi2cset_word(bus, devno, loc, level)
|
||
ret, value = rgi2cget_word(bus, devno, loc)
|
||
if strtoint(value) == level:
|
||
ret = 0
|
||
# enable protection
|
||
rgi2cset(bus, devno, protectaddr, close)
|
||
if ret == 0:
|
||
return True
|
||
return False
|
||
|
||
@staticmethod
|
||
def macPressure_adj(macavs, avs_param, mac_def_param):
|
||
# check whether it within range
|
||
max_adj = max(avs_param.keys())
|
||
min_adj = min(avs_param.keys())
|
||
type = mac_def_param["type"]
|
||
level = 0
|
||
if type == 0:
|
||
if macavs not in range(min_adj, max_adj + 1):
|
||
return False
|
||
else:
|
||
level = macavs
|
||
else:
|
||
if macavs not in range(min_adj, max_adj + 1):
|
||
level = mac_def_param["default"]
|
||
else:
|
||
level = macavs
|
||
ret = AVSUTIL.mac_avs_chip(
|
||
mac_def_param["bus"],
|
||
mac_def_param["devno"],
|
||
mac_def_param["addr"],
|
||
mac_def_param["open"],
|
||
mac_def_param["close"],
|
||
mac_def_param["loop"],
|
||
mac_def_param["protectaddr"],
|
||
avs_param[level],
|
||
mac_def_param["loopaddr"],
|
||
)
|
||
return ret
|
||
|
||
@staticmethod
|
||
def mac_adj():
|
||
macavs = 0
|
||
name = MAC_DEFAULT_PARAM["sdkreg"]
|
||
ret, status = getSdkReg(name)
|
||
if ret == False:
|
||
return False
|
||
status = strtoint(status)
|
||
# shift operation
|
||
if MAC_DEFAULT_PARAM["sdktype"] != 0:
|
||
status = (status >> MAC_DEFAULT_PARAM["macregloc"]) & MAC_DEFAULT_PARAM[
|
||
"mask"
|
||
]
|
||
macavs = status
|
||
ret = AVSUTIL.macPressure_adj(macavs, MAC_AVS_PARAM, MAC_DEFAULT_PARAM)
|
||
return ret
|
||
|
||
|
||
class I2CUTIL:
|
||
@staticmethod
|
||
def getvaluefromdevice(name):
|
||
ret = []
|
||
for item in DEVICE:
|
||
if item["name"] == name:
|
||
ret.append(item)
|
||
return ret
|
||
|
||
@staticmethod
|
||
def openFanE2Protect():
|
||
rgi2cset(
|
||
FAN_PROTECT["bus"],
|
||
FAN_PROTECT["devno"],
|
||
FAN_PROTECT["addr"],
|
||
FAN_PROTECT["open"],
|
||
)
|
||
|
||
@staticmethod
|
||
def closeFanE2Protect():
|
||
rgi2cset(
|
||
FAN_PROTECT["bus"],
|
||
FAN_PROTECT["devno"],
|
||
FAN_PROTECT["addr"],
|
||
FAN_PROTECT["close"],
|
||
)
|
||
|
||
@staticmethod
|
||
def writeToFanE2(bus, loc, rst_arr):
|
||
index = 0
|
||
for item in rst_arr:
|
||
rgi2cset(bus, loc, index, ord(item))
|
||
index += 1
|
||
|
||
@staticmethod
|
||
def writeToE2(bus, loc, rst_arr):
|
||
index = 0
|
||
for item in rst_arr:
|
||
rgi2cset(bus, loc, index, ord(item))
|
||
index += 1
|
||
|
||
@staticmethod
|
||
def getE2File(bus, loc):
|
||
return "/sys/bus/i2c/devices/%d-00%02x/eeprom" % (bus, loc)
|
||
|
||
|
||
class BMC:
|
||
_instance_lock = threading.Lock()
|
||
|
||
def __init__(self):
|
||
pass
|
||
|
||
def __new__(cls, *args, **kwargs):
|
||
if not hasattr(Singleton, "_instance"):
|
||
with Singleton._instance_lock:
|
||
if not hasattr(Singleton, "_instance"):
|
||
Singleton._instance = object.__new__(cls)
|
||
return Singleton._instance
|
||
|
||
|
||
# Internal interface
|
||
|
||
|
||
def getSdkReg(reg):
|
||
try:
|
||
cmd = "bcmcmd -t 1 'getr %s ' < /dev/null" % reg
|
||
ret, result = os_system(cmd)
|
||
result_t = result.strip().replace("\r", "").replace("\n", "")
|
||
if ret != 0 or "Error:" in result_t:
|
||
return False, result
|
||
patt = r"%s.(.*):(.*)>drivshell" % reg
|
||
rt = re.findall(patt, result_t, re.S)
|
||
test = re.findall("=(.*)", rt[0][0])[0]
|
||
except Exception as e:
|
||
return False, "getsdk register error"
|
||
return True, test
|
||
|
||
|
||
def getfilevalue(location):
|
||
try:
|
||
with open(location, "r") as fd:
|
||
value = fd.read()
|
||
return True, value.strip()
|
||
except Exception as e:
|
||
return False, "error"
|
||
|
||
|
||
def get_sysfs_value(location):
|
||
pos_t = str(location)
|
||
name = get_pmc_register(pos_t)
|
||
return name
|
||
|
||
|
||
def write_sysfs_value(reg_name, value):
|
||
fileLoc = MAILBOX_DIR + reg_name
|
||
try:
|
||
if not os.path.isfile(fileLoc):
|
||
print(fileLoc, "not found !")
|
||
return False
|
||
with open(fileLoc, "w") as fd:
|
||
fd.write(value)
|
||
except Exception as error:
|
||
log_error("Unable to open " + fileLoc + "file !")
|
||
return False
|
||
return True
|
||
|
||
|
||
def RJPRINTERR(str):
|
||
print("\033[0;31m%s\033[0m" % str)
|
||
|
||
|
||
def strtoint(str): # convert Hex string to int such as "4040"/"0x4040"/"0X4040" = 16448
|
||
value = 0
|
||
rest_v = str.replace("0X", "").replace("0x", "")
|
||
for index in range(len(rest_v)):
|
||
print(rest_v[index])
|
||
value |= int(rest_v[index], 16) << ((len(rest_v) - index - 1) * 4)
|
||
return value
|
||
|
||
|
||
def inttostr(vl, len): # convert int to string such as 0x3030 = 00
|
||
if type(vl) != int:
|
||
raise Exception(" type error")
|
||
index = 0
|
||
ret_t = ""
|
||
while index < len:
|
||
ret = 0xFF & (vl >> index * 8)
|
||
ret_t += chr(ret)
|
||
index += 1
|
||
return ret_t
|
||
|
||
|
||
def str_to_hex(rest_v):
|
||
value = 0
|
||
for index in range(len(rest_v)):
|
||
value |= ord(rest_v[index]) << ((len(rest_v) - index - 1) * 8)
|
||
return value
|
||
|
||
|
||
def hex_to_str(s):
|
||
len_t = len(s)
|
||
if len_t % 2 != 0:
|
||
return 0
|
||
ret = ""
|
||
for t in range(0, int(len_t / 2)):
|
||
ret += chr(int(s[2 * t : 2 * t + 2], 16))
|
||
return ret
|
||
|
||
|
||
def str_to_bin(s):
|
||
return " ".join([bin(ord(c)).replace("0b", "") for c in s])
|
||
|
||
|
||
def bin_to_str(s):
|
||
return "".join([chr(i) for i in [int(b, 2) for b in s.split(" ")]])
|
||
|
||
|
||
def get_mac_temp():
|
||
result = {}
|
||
# wait_docker()
|
||
# exec twice, get the second result
|
||
os_system('bcmcmd -t 1 "show temp" < /dev/null')
|
||
ret, log = os_system('bcmcmd -t 1 "show temp" < /dev/null')
|
||
if ret:
|
||
return False, result
|
||
else:
|
||
# decode obtained info
|
||
logs = log.splitlines()
|
||
for line in logs:
|
||
if "average" in line:
|
||
b = re.findall(r"\d+.\d+", line)
|
||
result["average"] = b[0]
|
||
elif "maximum" in line:
|
||
b = re.findall(r"\d+.\d+", line)
|
||
result["maximum"] = b[0]
|
||
return True, result
|
||
|
||
|
||
def get_mac_temp_sysfs(mactempconf):
|
||
try:
|
||
temp = -1000000
|
||
temp_list = []
|
||
mac_temp_loc = mactempconf.get("loc", [])
|
||
mac_temp_flag = mactempconf.get("flag", None)
|
||
if mac_temp_flag is not None: # check mac temperature vaild flag
|
||
gettype = mac_temp_flag.get("gettype")
|
||
okbit = mac_temp_flag.get("okbit")
|
||
okval = mac_temp_flag.get("okval")
|
||
if gettype == "io":
|
||
io_addr = mac_temp_flag.get("io_addr")
|
||
val = io_rd(io_addr)
|
||
if val is None:
|
||
raise Exception("get mac_flag by io failed.")
|
||
else:
|
||
bus = mac_temp_flag.get("bus")
|
||
loc = mac_temp_flag.get("loc")
|
||
offset = mac_temp_flag.get("offset")
|
||
ind, val = rgi2cget(bus, loc, offset)
|
||
if ind is not True:
|
||
raise Exception("get mac_flag by i2c failed.")
|
||
val_t = (int(val, 16) & (1 << okbit)) >> okbit
|
||
if val_t != okval:
|
||
raise Exception("mac_flag invalid, val_t:%d." % val_t)
|
||
for loc in mac_temp_loc:
|
||
temp_s = get_sysfs_value(loc)
|
||
if isinstance(temp_s, str) and temp_s.startswith("ERR"):
|
||
raise Exception("get mac temp error. loc:%s" % loc)
|
||
temp_t = int(temp_s)
|
||
if temp_t == -1000000:
|
||
raise Exception("mac temp invalid.loc:%s" % loc)
|
||
temp_list.append(temp_t)
|
||
temp_list.sort(reverse=True)
|
||
temp = temp_list[0]
|
||
except Exception as e:
|
||
return False, temp
|
||
return True, temp
|
||
|
||
|
||
def restartDockerService(force=False):
|
||
container_name = [
|
||
"database",
|
||
"snmp",
|
||
"syncd",
|
||
"swss",
|
||
"dhcp_relay",
|
||
"radv",
|
||
"teamd",
|
||
"pmon",
|
||
]
|
||
ret, status = os_system("docker ps")
|
||
if ret == 0:
|
||
for tmpname in container_name:
|
||
if tmpname not in status:
|
||
if force == True:
|
||
os_system("docker restart %s" % tmpname)
|
||
else:
|
||
os_system("systemctl restart %s" % tmpname)
|
||
|
||
|
||
def wait_dhcp(timeout):
|
||
time_cnt = 0
|
||
while True:
|
||
try:
|
||
ret, status = os_system("systemctl status dhcp_relay.service")
|
||
if (ret == 0 and "running" in status) or "SUCCESS" in status:
|
||
break
|
||
else:
|
||
sys.stdout.write(".")
|
||
sys.stdout.flush()
|
||
time_cnt = time_cnt + 1
|
||
if time_cnt > timeout:
|
||
raise Exception("wait_dhcp timeout")
|
||
time.sleep(1)
|
||
except Exception as e:
|
||
return False
|
||
return True
|
||
|
||
|
||
def wait_sdk(sdk_fpath, timeout):
|
||
time_cnt = 0
|
||
while True:
|
||
try:
|
||
if os.path.exists(sdk_fpath):
|
||
break
|
||
else:
|
||
sys.stdout.write(".")
|
||
sys.stdout.flush()
|
||
time_cnt = time_cnt + 1
|
||
if time_cnt > timeout:
|
||
raise Exception("wait_sdk timeout")
|
||
time.sleep(1)
|
||
except Exception as e:
|
||
return False
|
||
return True
|
||
|
||
|
||
def wait_docker(need_restart=False, timeout=180):
|
||
sdkcheck_params = STARTMODULE.get("sdkcheck", {})
|
||
if sdkcheck_params.get("checktype") == "file": # pass file check
|
||
sdk_fpath = sdkcheck_params.get("sdk_fpath")
|
||
return wait_sdk(sdk_fpath, timeout)
|
||
return wait_dhcp(timeout)
|
||
|
||
|
||
def getTLV_BODY(type, productname):
|
||
x = []
|
||
temp_t = ""
|
||
if type == TLV_CODE_MAC_BASE:
|
||
arr = productname.split(":")
|
||
for tt in arr:
|
||
temp_t += chr(int(tt, 16))
|
||
elif type == TLV_CODE_DEVICE_VERSION:
|
||
temp_t = chr(productname)
|
||
elif type == TLV_CODE_MAC_SIZE:
|
||
temp_t = chr(productname >> 8) + chr(productname & 0x00FF)
|
||
else:
|
||
temp_t = productname
|
||
x.append(chr(type))
|
||
x.append(chr(len(temp_t)))
|
||
for i in temp_t:
|
||
x.append(i)
|
||
return x
|
||
|
||
|
||
def _crc32(v):
|
||
return "0x%08x" % (
|
||
binascii.crc32(v) & 0xFFFFFFFF
|
||
) # get 8 bytes of crc32 %x return hex
|
||
|
||
|
||
def printvalue(b):
|
||
index = 0
|
||
for i in range(0, len(b)):
|
||
if index % 16 == 0:
|
||
print(" ")
|
||
print("%02x " % ord(b[i]))
|
||
index += 1
|
||
print("\n")
|
||
|
||
|
||
def generate_value(_t):
|
||
ret = []
|
||
for i in TLV_INFO_ID_STRING:
|
||
ret.append(i)
|
||
ret.append(chr(TLV_INFO_VERSION))
|
||
ret.append(chr(TLV_INFO_LENGTH))
|
||
ret.append(chr(TLV_INFO_LENGTH_VALUE))
|
||
|
||
total_len = 0
|
||
for key in _t:
|
||
x = getTLV_BODY(key, _t[key])
|
||
ret += x
|
||
total_len += len(x)
|
||
ret[10] = chr(total_len + 6)
|
||
|
||
ret.append(chr(0xFE))
|
||
ret.append(chr(0x04))
|
||
s = _crc32("".join(ret))
|
||
for t in range(0, 4):
|
||
ret.append(chr(int(s[2 * t + 2 : 2 * t + 4], 16)))
|
||
totallen = len(ret)
|
||
if totallen < 256:
|
||
for left_t in range(0, 256 - totallen):
|
||
ret.append(chr(0x00))
|
||
return (ret, True)
|
||
|
||
|
||
def getsyseeprombyId(id):
|
||
ret = get_sys_eeprom()
|
||
for item in ret:
|
||
if item["code"] == id:
|
||
return item
|
||
return None
|
||
|
||
|
||
def fac_init_cardidcheck():
|
||
rest = getsyseeprombyId(TLV_CODE_RJ_CARID) # check cardId same or not
|
||
if rest is None:
|
||
print("need to program write bin file")
|
||
return False
|
||
else:
|
||
rest_v = rest["value"]
|
||
value = strtoint(rest_v)
|
||
if value == RAGILE_CARDID:
|
||
log_debug("check card ID pass")
|
||
else:
|
||
log_debug("check card ID error")
|
||
return False
|
||
return True
|
||
|
||
|
||
def isValidMac(mac):
|
||
if re.match(r"^\s*([0-9a-fA-F]{2,2}:){5,5}[0-9a-fA-F]{2,2}\s*$", mac):
|
||
return True
|
||
return False
|
||
|
||
|
||
# Internet cardsetmac
|
||
|
||
|
||
def util_setmac(eth, mac):
|
||
rulefile = "/etc/udev/rules.d/70-persistent-net.rules"
|
||
if isValidMac(mac) == False:
|
||
return False, "MAC invaild"
|
||
cmd = "ethtool -e %s | grep 0x0010 | awk '{print \"0x\"$13$12$15$14}'" % eth
|
||
ret, log = os_system(cmd)
|
||
log_debug(log)
|
||
magic = ""
|
||
if ret == 0 and len(log):
|
||
magic = log
|
||
macs = mac.upper().split(":")
|
||
|
||
# chage ETH0 to value after setmac
|
||
ifconfigcmd = "ifconfig eth0 hw ether %s" % mac
|
||
log_debug(ifconfigcmd)
|
||
ret, status = os_system(ifconfigcmd)
|
||
if ret:
|
||
raise SETMACException("software set Internet card MAC error")
|
||
index = 0
|
||
for item in macs:
|
||
cmd = "ethtool -E %s magic %s offset %d value 0x%s" % (eth, magic, index, item)
|
||
log_debug(cmd)
|
||
index += 1
|
||
ret, log = os_system(cmd)
|
||
if ret != 0:
|
||
raise SETMACException("set hardware Internet card MAC error")
|
||
# get value after setting
|
||
cmd_t = "ethtool -e eth0 offset 0 length 6"
|
||
ret, log = os_system(cmd_t)
|
||
m = re.split(":", log)[-1].strip().upper()
|
||
mac_result = m.upper().split(" ")
|
||
|
||
for ind, s in enumerate(macs):
|
||
if s != mac_result[ind]:
|
||
RJPRINTERR("MAC comparison error")
|
||
if os.path.exists(rulefile):
|
||
os.remove(rulefile)
|
||
print("MGMT MAC[%s]" % mac)
|
||
return True
|
||
|
||
|
||
def getInputCheck(tips):
|
||
str = raw_input(tips)
|
||
if (
|
||
astrcmp(str, "y")
|
||
or astrcmp(str, "ye")
|
||
or astrcmp(str, "yes")
|
||
or astrcmp(str, "")
|
||
):
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
|
||
def getrawch():
|
||
fd = sys.stdin.fileno()
|
||
old_settings = termios.tcgetattr(fd)
|
||
try:
|
||
tty.setraw(sys.stdin.fileno())
|
||
ch = sys.stdin.read(1)
|
||
finally:
|
||
termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
|
||
return ch
|
||
|
||
|
||
def upper_input(tips):
|
||
sys.stdout.write(tips)
|
||
sys.stdout.flush()
|
||
passwd = []
|
||
while True:
|
||
ch = getrawch().upper()
|
||
if ch == "\r" or ch == "\n":
|
||
return "".join(passwd)
|
||
elif ch == "\b" or ord(ch) == 127:
|
||
if passwd:
|
||
del passwd[-1]
|
||
sys.stdout.write("\b \b")
|
||
else:
|
||
sys.stdout.write(ch)
|
||
passwd.append(ch)
|
||
|
||
|
||
def changeTypeValue(_value, type1, tips, example):
|
||
if type1 == TLV_CODE_PRODUCT_NAME:
|
||
while True:
|
||
print(
|
||
"please check (1)air from forward to backward/(2)air from backward to forward:"
|
||
)
|
||
option = raw_input()
|
||
if option == "1":
|
||
_value[type1] = example + "-F-RJ"
|
||
print(
|
||
"check Product is air from forward to backward device,Product Name:%s"
|
||
% _value[type1]
|
||
)
|
||
break
|
||
elif option == "2":
|
||
_value[type1] = example + "-R-RJ"
|
||
print(
|
||
"check Product is air from backward to forward device,Product Name:%s"
|
||
% _value[type1]
|
||
)
|
||
break
|
||
else:
|
||
print("input incorrect, check please")
|
||
return True
|
||
print("Please input[%s]such as(%s):" % (tips, example))
|
||
name = upper_input("")
|
||
if type1 == TLV_CODE_MAC_BASE:
|
||
if len(name) != 12:
|
||
raise SETMACException("MAC address length incorrect, check please")
|
||
release_mac = ""
|
||
for i in range(int(len(name) / 2)):
|
||
if i == 0:
|
||
release_mac += name[i * 2 : i * 2 + 2]
|
||
else:
|
||
release_mac += ":" + name[i * 2 : i * 2 + 2]
|
||
if isValidMac(release_mac) == True:
|
||
_value[type1] = release_mac
|
||
else:
|
||
raise SETMACException("MAC address invaild, check please")
|
||
elif type1 == TLV_CODE_DEVICE_VERSION:
|
||
if name.isdigit():
|
||
_value[type1] = int(name)
|
||
else:
|
||
raise SETMACException("Version is not number, check please")
|
||
elif type1 == TLV_CODE_MAC_SIZE:
|
||
if name.isdigit():
|
||
_value[type1] = int(name, 16)
|
||
else:
|
||
raise SETMACException("Version is not number, check please")
|
||
elif type1 == TLV_CODE_SERIAL_NUMBER:
|
||
if name.isalnum() == False:
|
||
raise SETMACException("Serial Number invaild string, check please")
|
||
elif len(name) != 13:
|
||
raise SETMACException("Serial Number length incorrect, check please")
|
||
else:
|
||
_value[type1] = name
|
||
elif type1 == TLV_CODE_VENDOR_EXT:
|
||
_value[type1] = name
|
||
else:
|
||
_value[type1] = name
|
||
return True
|
||
|
||
|
||
def astrcmp(str1, str2):
|
||
return str1.lower() == str2.lower()
|
||
|
||
|
||
def generate_ext(cardid):
|
||
s = "%08x" % cardid
|
||
ret = ""
|
||
for t in range(0, 4):
|
||
ret += chr(int(s[2 * t : 2 * t + 2], 16))
|
||
ret = chr(0x01) + chr(len(ret)) + ret
|
||
return ret
|
||
|
||
|
||
def rgi2cget(bus, devno, address):
|
||
command_line = "i2cget -f -y %d 0x%02x 0x%02x " % (bus, devno, address)
|
||
retrytime = 6
|
||
ret_t = ""
|
||
for i in range(retrytime):
|
||
ret, ret_t = os_system(command_line)
|
||
if ret == 0:
|
||
return True, ret_t
|
||
time.sleep(0.1)
|
||
return False, ret_t
|
||
|
||
|
||
def rgi2cset(bus, devno, address, byte):
|
||
command_line = "i2cset -f -y %d 0x%02x 0x%02x 0x%02x" % (bus, devno, address, byte)
|
||
retrytime = 6
|
||
ret_t = ""
|
||
for i in range(retrytime):
|
||
ret, ret_t = os_system(command_line)
|
||
if ret == 0:
|
||
return True, ret_t
|
||
return False, ret_t
|
||
|
||
|
||
def rgpcird(pcibus, slot, fn, bar, offset):
|
||
"""read pci register"""
|
||
if offset % 4 != 0:
|
||
return
|
||
filename = "/sys/bus/pci/devices/0000:%02x:%02x.%x/resource%d" % (
|
||
int(pcibus),
|
||
int(slot),
|
||
int(fn),
|
||
int(bar),
|
||
)
|
||
file = open(filename, "r+")
|
||
size = os.path.getsize(filename)
|
||
data = mmap.mmap(file.fileno(), size)
|
||
result = data[offset : offset + 4]
|
||
s = result[::-1]
|
||
val = 0
|
||
for i in range(0, len(s)):
|
||
val = val << 8 | s[i]
|
||
return "0x%08x" % val
|
||
|
||
|
||
def rgpciwr(pcibus, slot, fn, bar, offset, data):
|
||
"""write pci register"""
|
||
ret = inttostr(data, 4)
|
||
ret = str.encode(ret)
|
||
ret = ret.strip(b'\xc2')
|
||
filename = "/sys/bus/pci/devices/0000:%02x:%02x.%x/resource%d" % (
|
||
int(pcibus),
|
||
int(slot),
|
||
int(fn),
|
||
int(bar),
|
||
)
|
||
file = open(filename, "r+")
|
||
size = os.path.getsize(filename)
|
||
data = mmap.mmap(file.fileno(), size)
|
||
data[offset : offset + 4] = ret
|
||
result = data[offset : offset + 4]
|
||
s = result[::-1]
|
||
val = 0
|
||
for i in range(0, len(s)):
|
||
val = val << 8 | s[i]
|
||
data.close()
|
||
|
||
|
||
def rgsysset(location, value):
|
||
command_line = "echo 0x%02x > %s" % (value, location)
|
||
retrytime = 6
|
||
ret_t = ""
|
||
for i in range(retrytime):
|
||
ret, ret_t = os_system(command_line)
|
||
if ret == 0:
|
||
return True, ret_t
|
||
return False, ret_t
|
||
|
||
|
||
def rgi2cget_word(bus, devno, address):
|
||
command_line = "i2cget -f -y %d 0x%02x 0x%02x w" % (bus, devno, address)
|
||
retrytime = 3
|
||
ret_t = ""
|
||
for i in range(retrytime):
|
||
ret, ret_t = os_system(command_line)
|
||
if ret == 0:
|
||
return True, ret_t
|
||
return False, ret_t
|
||
|
||
|
||
def rgi2cset_word(bus, devno, address, byte):
|
||
command_line = "i2cset -f -y %d 0x%02x 0x%02x 0x%x w" % (bus, devno, address, byte)
|
||
os_system(command_line)
|
||
|
||
|
||
def fan_setmac():
|
||
rgi2cset(
|
||
FAN_PROTECT["bus"],
|
||
FAN_PROTECT["devno"],
|
||
FAN_PROTECT["addr"],
|
||
FAN_PROTECT["open"],
|
||
)
|
||
rgi2cset(
|
||
FAN_PROTECT["bus"],
|
||
FAN_PROTECT["devno"],
|
||
FAN_PROTECT["addr"],
|
||
FAN_PROTECT["close"],
|
||
)
|
||
|
||
|
||
def checkfansninput(fan_sn, fansntemp):
|
||
if fan_sn in fansntemp:
|
||
RJPRINTERR("exist same Serial Number，please input again")
|
||
return False
|
||
if len(fan_sn) != 13:
|
||
RJPRINTERR("Serial Number length incorrect，please input again")
|
||
return False
|
||
return True
|
||
|
||
|
||
# check hw version
|
||
def checkfanhwinput(hw):
|
||
if len(hw) != 4:
|
||
RJPRINTERR("hardware version length incorrect, please input again")
|
||
return False
|
||
if hw.find(".") != 1:
|
||
RJPRINTERR("hardware version incorrect, please input again")
|
||
return False
|
||
return True
|
||
|
||
|
||
def util_show_fanse2(fans):
|
||
formatstr = "%-8s %-20s %-20s %-20s %-20s"
|
||
print(formatstr % ("id", "Name", "hardware version", "Serial Number", "Time"))
|
||
print(
|
||
formatstr
|
||
% ("------", "---------------", "---------------", "---------------", "----")
|
||
)
|
||
for fan in fans:
|
||
# print fan.dstatus
|
||
if fan.dstatus < 0:
|
||
print("%-8s" % ("FAN%d" % (fans.index(fan) + 1)))
|
||
RJPRINTERR(" decode e2 error")
|
||
else:
|
||
print(
|
||
formatstr
|
||
% (
|
||
"FAN%d" % (fans.index(fan) + 1),
|
||
fan.typename.replace(chr(0x00), ""),
|
||
fan.typehwinfo.replace(chr(0x00), ""),
|
||
fan.typesn.replace(chr(0x00), ""),
|
||
fan.fandecodetime,
|
||
)
|
||
)
|
||
|
||
|
||
def get_fane2_sysfs(bus, loc):
|
||
rg_fan_e2 = "%d-%04x/fan" % (bus, loc)
|
||
eeprom = get_sysfs_value(rg_fan_e2)
|
||
return eeprom
|
||
|
||
|
||
def util_show_fane2():
|
||
ret = sorted(I2CUTIL.getvaluefromdevice("rg_fan"))
|
||
if len(ret) <= 0:
|
||
return None
|
||
fans = []
|
||
for index in range(len(ret)):
|
||
t1 = int(round(time.time() * 1000))
|
||
eeprom = get_fane2_sysfs(ret[index]["bus"], ret[index]["loc"])
|
||
t2 = int(round(time.time() * 1000))
|
||
fane2 = fan_tlv()
|
||
fane2.fandecodetime = t2 - t1
|
||
fane2.decode(eeprom)
|
||
fans.append(fane2)
|
||
util_show_fanse2(fans)
|
||
|
||
|
||
def getPid(name):
|
||
ret = []
|
||
for dirname in os.listdir("/proc"):
|
||
if dirname == "curproc":
|
||
continue
|
||
try:
|
||
with open("/proc/{}/cmdline".format(dirname), mode="rb") as fd:
|
||
content = fd.read()
|
||
except Exception:
|
||
continue
|
||
if name in content:
|
||
ret.append(dirname)
|
||
return ret
|
||
|
||
|
||
def fac_fans_setmac_tlv(ret):
|
||
if len(ret) <= 0:
|
||
return None
|
||
fans = []
|
||
fansntemp = []
|
||
for index in range(len(ret)):
|
||
item = ret[index]
|
||
log_debug(item)
|
||
eeprom = get_fane2_sysfs(item["bus"], item["loc"])
|
||
fane2 = fan_tlv()
|
||
fane2.decode(eeprom)
|
||
fane2.fanbus = item["bus"]
|
||
fane2.fanloc = item["loc"]
|
||
log_debug("decode eeprom success")
|
||
|
||
print("Fan[%d]-[%s]setmac" % ((index + 1), FANS_DEF[fane2.typedevtype]))
|
||
while True:
|
||
print("Please input[%s]:" % "Serial Number")
|
||
fan_sn = raw_input()
|
||
if checkfansninput(fan_sn, fansntemp) == False:
|
||
continue
|
||
fansntemp.append(fan_sn)
|
||
fan_sn = fan_sn + chr(0x00)
|
||
fane2.typesn = fan_sn + chr(0x00)
|
||
break
|
||
while True:
|
||
print("Please input[%s]:" % "hardware version")
|
||
hwinfo = raw_input()
|
||
if checkfanhwinput(hwinfo) == False:
|
||
continue
|
||
fan_hwinfo = hwinfo + chr(0x00)
|
||
fane2.typehwinfo = fan_hwinfo + chr(0x00)
|
||
break
|
||
log_debug(fane2.typedevtype)
|
||
fane2.typename = FANS_DEF[fane2.typedevtype] + chr(0x00)
|
||
fans.append(fane2)
|
||
print("\n")
|
||
print("\n*******************************\n")
|
||
|
||
util_show_fanse2(fans)
|
||
if getInputCheck("check input correctly or not（Yes/No):") == True:
|
||
for fan in fans:
|
||
log_debug("ouput fan")
|
||
fac_fan_setmac(fan)
|
||
else:
|
||
print("setmac quit")
|
||
return False
|
||
|
||
|
||
def fac_fan_setmac_fru(ret):
|
||
fans = FRULISTS.get("fans")
|
||
|
||
fanfrus = {}
|
||
newfrus = {}
|
||
|
||
# getmsg
|
||
try:
|
||
for fan in fans:
|
||
print("===============%s ================getmessage" % fan.get("name"))
|
||
eeprom = getsysvalue(I2CUTIL.getE2File(fan.get("bus"), fan.get("loc")))
|
||
fru = ipmifru()
|
||
fru.decodeBin(eeprom)
|
||
fanfrus[fan.get("name")] = fru
|
||
except Exception as e:
|
||
print(str(e))
|
||
return False
|
||
|
||
# setmsg
|
||
for fan in fans:
|
||
print("===============%s ================setmac" % fan.get("name"))
|
||
fruold = fanfrus.get(fan.get("name"))
|
||
newfru = getInputSetmac(fruold)
|
||
newfru.recalcute()
|
||
newfrus[fan.get("name")] = newfru
|
||
# writemsg
|
||
for fan in fans:
|
||
print("===============%s ================writeToE2" % fan.get("name"))
|
||
ret_t = newfrus.get(fan.get("name"))
|
||
I2CUTIL.openFanE2Protect()
|
||
I2CUTIL.writeToFanE2(fan.get("bus"), fan.get("loc"), ret_t.bindata)
|
||
I2CUTIL.closeFanE2Protect()
|
||
# check
|
||
try:
|
||
for fan in fans:
|
||
print("===============%s ================getmessage" % fan.get("name"))
|
||
eeprom = getsysvalue(I2CUTIL.getE2File(fan.get("bus"), fan.get("loc")))
|
||
fru = ipmifru()
|
||
fru.decodeBin(eeprom)
|
||
except Exception as e:
|
||
print(str(e))
|
||
return False
|
||
return True
|
||
|
||
|
||
def fac_fans_setmac():
|
||
ret = I2CUTIL.getvaluefromdevice("rg_fan")
|
||
if ret is not None and len(ret) > 0:
|
||
return fac_fans_setmac_tlv(ret)
|
||
fans = FRULISTS.get("fans", None)
|
||
if fans is not None and len(fans) > 0:
|
||
return fac_fan_setmac_fru(ret)
|
||
return False
|
||
|
||
|
||
def fac_fan_setmac(item):
|
||
I2CUTIL.openFanE2Protect()
|
||
I2CUTIL.writeToFanE2(item.fanbus, item.fanloc, item.generate_fan_value())
|
||
I2CUTIL.closeFanE2Protect()
|
||
|
||
|
||
def writeToEEprom(rst_arr):
|
||
dealtype = E2_PROTECT.get("gettype", None)
|
||
if dealtype is None:
|
||
rgi2cset(
|
||
E2_PROTECT["bus"],
|
||
E2_PROTECT["devno"],
|
||
E2_PROTECT["addr"],
|
||
E2_PROTECT["open"],
|
||
)
|
||
elif dealtype == "io":
|
||
io_wr(E2_PROTECT["io_addr"], E2_PROTECT["open"])
|
||
index = 0
|
||
for item in rst_arr:
|
||
rgi2cset(E2_LOC["bus"], E2_LOC["devno"], index, ord(item))
|
||
index += 1
|
||
|
||
if dealtype is None:
|
||
rgi2cset(
|
||
E2_PROTECT["bus"],
|
||
E2_PROTECT["devno"],
|
||
E2_PROTECT["addr"],
|
||
E2_PROTECT["close"],
|
||
)
|
||
elif dealtype == "io":
|
||
io_wr(E2_PROTECT["io_addr"], E2_PROTECT["close"])
|
||
# deal last drivers
|
||
os.system("rmmod at24 ")
|
||
os.system("modprobe at24 ")
|
||
os.system("rm -f /var/cache/sonic/decode-syseeprom/syseeprom_cache")
|
||
|
||
|
||
def get_local_eth0_mac():
|
||
cmd = "ifconfig eth0 |grep HWaddr"
|
||
print(os_system(cmd))
|
||
|
||
|
||
def getonieversion():
|
||
if not os.path.isfile("/host/machine.conf"):
|
||
return ""
|
||
machine_vars = {}
|
||
with open("/host/machine.conf") as machine_file:
|
||
for line in machine_file:
|
||
tokens = line.split("=")
|
||
if len(tokens) < 2:
|
||
continue
|
||
machine_vars[tokens[0]] = tokens[1].strip()
|
||
return machine_vars.get("onie_version")
|
||
|
||
|
||
def createbmcMac(cpumac, num=2):
|
||
bcmvalue = strtoint(cpumac[cpumac.rindex(":") + 1 : len(cpumac)]) + num
|
||
# bmcmac =
|
||
t = cpumac.split(":")
|
||
t[5] = "%02x" % bcmvalue
|
||
bmcmac = ":".join(t)
|
||
return bmcmac.upper()
|
||
|
||
|
||
def fac_board_setmac():
|
||
_value = {}
|
||
# default value
|
||
_value[TLV_CODE_VENDOR_EXT] = generate_ext(RAGILE_CARDID) # generate id
|
||
_value[TLV_CODE_PRODUCT_NAME] = RAGILE_PRODUCTNAME
|
||
_value[TLV_CODE_PART_NUMBER] = RAGILE_PART_NUMBER
|
||
_value[TLV_CODE_LABEL_REVISION] = RAGILE_LABEL_REVISION
|
||
_value[TLV_CODE_PLATFORM_NAME] = platform
|
||
_value[TLV_CODE_ONIE_VERSION] = getonieversion()
|
||
_value[TLV_CODE_MAC_SIZE] = RAGILE_MAC_SIZE
|
||
_value[TLV_CODE_MANUF_NAME] = RAGILE_MANUF_NAME
|
||
_value[TLV_CODE_MANUF_COUNTRY] = RAGILE_MANUF_COUNTRY
|
||
_value[TLV_CODE_VENDOR_NAME] = RAGILE_VENDOR_NAME
|
||
_value[TLV_CODE_DIAG_VERSION] = RAGILE_DIAG_VERSION
|
||
_value[TLV_CODE_SERVICE_TAG] = RAGILE_SERVICE_TAG
|
||
try:
|
||
if 0x00004052 == RAGILE_CARDID:
|
||
_value[TLV_CODE_PRODUCT_NAME] = RAGILE_PRODUCTNAME + "-RJ"
|
||
elif 0x00004051 == RAGILE_CARDID or 0x00004050 == RAGILE_CARDID:
|
||
changeTypeValue(
|
||
_value, TLV_CODE_PRODUCT_NAME, "Product name", RAGILE_PRODUCTNAME
|
||
)
|
||
|
||
changeTypeValue(
|
||
_value, TLV_CODE_SERIAL_NUMBER, "SN", "0000000000000"
|
||
) # add serial number
|
||
changeTypeValue(
|
||
_value, TLV_CODE_DEVICE_VERSION, "hardware version", "101"
|
||
) # hardware version
|
||
changeTypeValue(
|
||
_value, TLV_CODE_MAC_BASE, "MAC address", "58696cfb2108"
|
||
) # MAC address
|
||
_value[TLV_CODE_MANUF_DATE] = time.strftime(
|
||
"%m/%d/%Y %H:%M:%S", time.localtime()
|
||
) # add setmac time
|
||
rst, ret = generate_value(_value)
|
||
if (
|
||
util_setmac("eth0", _value[TLV_CODE_MAC_BASE]) == True
|
||
): # set Internet cardIP
|
||
writeToEEprom(rst) # write to e2
|
||
# set BMC MAC
|
||
if "bmcsetmac" in FACTESTMODULE and FACTESTMODULE["bmcsetmac"] == 1:
|
||
bmcmac = createbmcMac(_value[TLV_CODE_MAC_BASE])
|
||
if ipmi_set_mac(bmcmac) == True:
|
||
print("BMC MAC[%s]" % bmcmac)
|
||
else:
|
||
print("SET BMC MAC FAILED")
|
||
return False
|
||
else:
|
||
return False
|
||
except SETMACException as e:
|
||
# print(e)
|
||
RJPRINTERR("\n\n%s\n\n" % e)
|
||
return False
|
||
except ValueError as e:
|
||
return False
|
||
return True
|
||
|
||
|
||
def ipmi_set_mac(mac):
|
||
macs = mac.split(":")
|
||
cmdinit = "ipmitool raw 0x0c 0x01 0x01 0xc2 0x00"
|
||
cmdset = "ipmitool raw 0x0c 0x01 0x01 0x05"
|
||
for ind in range(len(macs)):
|
||
cmdset += " 0x%02x" % int(macs[ind], 16)
|
||
os_system(cmdinit)
|
||
ret, status = os_system(cmdset)
|
||
if ret:
|
||
RJPRINTERR("\n\n%s\n\n" % status)
|
||
return False
|
||
return True
|
||
|
||
|
||
def getInputValue(title, tips):
|
||
print("Please input[%s]such as(%s):" % (title, tips))
|
||
name = raw_input()
|
||
|
||
return name
|
||
|
||
|
||
def bmc_setmac():
|
||
tips = "BMC MAC"
|
||
print("Please input value you want to change[%s]:" % tips)
|
||
name = raw_input()
|
||
if len(name) != 12:
|
||
RJPRINTERR("\nMAC address invaild, try again\n")
|
||
return False
|
||
release_mac = ""
|
||
for i in range(int(len(name) / 2)):
|
||
if i == 0:
|
||
release_mac += name[i * 2 : i * 2 + 2]
|
||
else:
|
||
release_mac += ":" + name[i * 2 : i * 2 + 2]
|
||
if isValidMac(release_mac) == True:
|
||
if ipmi_set_mac(release_mac) == True:
|
||
return True
|
||
else:
|
||
RJPRINTERR("\nMAC address invaild, try again\n")
|
||
return False
|
||
|
||
|
||
def closeProtocol():
|
||
# disable LLDP
|
||
log_info("disable LLDP")
|
||
sys.stdout.write(".")
|
||
sys.stdout.flush()
|
||
os_system("systemctl stop lldp.service")
|
||
log_info("disable lldp service")
|
||
sys.stdout.write(".")
|
||
sys.stdout.flush()
|
||
os_system("systemctl stop bgp.service")
|
||
log_info("disable bgp service")
|
||
sys.stdout.write(".")
|
||
sys.stdout.flush()
|
||
# ret, status = os_system('bcmcmd "port ce,xe stp=disable"')
|
||
|
||
|
||
# check SDK memory must be 256M
|
||
|
||
|
||
def checkSdkMem():
|
||
ind = 0
|
||
file_data = ""
|
||
with open(file_name, "r") as f:
|
||
for line in f:
|
||
if "dmasize=16M" in line:
|
||
line = line.replace("dmasize=16M", "dmasize=256M")
|
||
ind = -1
|
||
file_data += line
|
||
if ind == 0:
|
||
return
|
||
with open(file_name, "w") as f:
|
||
f.write(file_data)
|
||
print("change SDK memory to 256, reboot required")
|
||
os_system("sync")
|
||
os_system("reboot")
|
||
|
||
|
||
##########################################################################
|
||
# receives a character setting
|
||
##########################################################################
|
||
|
||
|
||
def getch(msg):
|
||
ret = ""
|
||
fd = sys.stdin.fileno()
|
||
old_ttyinfo = termios.tcgetattr(fd)
|
||
new_ttyinfo = old_ttyinfo[:]
|
||
new_ttyinfo[3] &= ~termios.ICANON
|
||
new_ttyinfo[3] &= ~termios.ECHO
|
||
sys.stdout.write(msg)
|
||
sys.stdout.flush()
|
||
try:
|
||
termios.tcsetattr(fd, termios.TCSANOW, new_ttyinfo)
|
||
ret = os.read(fd, 1)
|
||
finally:
|
||
# print "try to setting"
|
||
termios.tcsetattr(fd, termios.TCSANOW, old_ttyinfo)
|
||
return ret
|
||
|
||
|
||
def get_raw_input():
|
||
ret = ""
|
||
fd = sys.stdin.fileno()
|
||
old_ttyinfo = termios.tcgetattr(fd)
|
||
new_ttyinfo = old_ttyinfo[:]
|
||
new_ttyinfo[3] &= ~termios.ICANON
|
||
new_ttyinfo[3] &= ~termios.ECHO
|
||
try:
|
||
termios.tcsetattr(fd, termios.TCSANOW, new_ttyinfo)
|
||
ret = raw_input("")
|
||
except Exception as e:
|
||
print(e)
|
||
finally:
|
||
termios.tcsetattr(fd, termios.TCSANOW, old_ttyinfo)
|
||
return ret
|
||
|
||
|
||
def getsysvalue(location):
|
||
retval = None
|
||
mb_reg_file = location
|
||
if not os.path.isfile(mb_reg_file):
|
||
print(mb_reg_file, "not found !")
|
||
return retval
|
||
try:
|
||
if not os.path.isfile(mb_reg_file):
|
||
print(mb_reg_file, "not found !")
|
||
return retval
|
||
with open(mb_reg_file, "r") as fd:
|
||
retval = fd.read()
|
||
except Exception as error:
|
||
log_error("Unable to open " + mb_reg_file + "file !")
|
||
retval = retval.rstrip("\r\n")
|
||
retval = retval.lstrip(" ")
|
||
# log_debug(retval)
|
||
return retval
|
||
|
||
|
||
# get file value
|
||
|
||
|
||
def get_pmc_register(reg_name):
|
||
retval = "ERR"
|
||
mb_reg_file = MAILBOX_DIR + reg_name
|
||
filepath = glob.glob(mb_reg_file)
|
||
if len(filepath) == 0:
|
||
return "%s %s notfound" % (retval, mb_reg_file)
|
||
mb_reg_file = filepath[0]
|
||
if not os.path.isfile(mb_reg_file):
|
||
return "%s %s notfound" % (retval, mb_reg_file)
|
||
try:
|
||
with open(mb_reg_file, "r") as fd:
|
||
retval = fd.read()
|
||
except Exception as error:
|
||
pass
|
||
retval = retval.rstrip("\r\n")
|
||
retval = retval.lstrip(" ")
|
||
return retval
|
||
|
||
|
||
# decode EEPROM
|
||
|
||
|
||
def decoder(s, t):
|
||
if ord(t[0]) == TLV_CODE_PRODUCT_NAME:
|
||
name = "Product Name"
|
||
value = str(t[2 : 2 + ord(t[1])])
|
||
elif ord(t[0]) == TLV_CODE_PART_NUMBER:
|
||
name = "Part Number"
|
||
value = t[2 : 2 + ord(t[1])]
|
||
elif ord(t[0]) == TLV_CODE_SERIAL_NUMBER:
|
||
name = "Serial Number"
|
||
value = t[2 : 2 + ord(t[1])]
|
||
elif ord(t[0]) == TLV_CODE_MAC_BASE:
|
||
name = "Base MAC Address"
|
||
value = ":".join([binascii.b2a_hex(T) for T in t[2:8]]).upper()
|
||
elif ord(t[0]) == TLV_CODE_MANUF_DATE:
|
||
name = "Manufacture Date"
|
||
value = t[2 : 2 + ord(t[1])]
|
||
elif ord(t[0]) == TLV_CODE_DEVICE_VERSION:
|
||
name = "Device Version"
|
||
value = str(ord(t[2]))
|
||
elif ord(t[0]) == TLV_CODE_LABEL_REVISION:
|
||
name = "Label Revision"
|
||
value = t[2 : 2 + ord(t[1])]
|
||
elif ord(t[0]) == TLV_CODE_PLATFORM_NAME:
|
||
name = "Platform Name"
|
||
value = t[2 : 2 + ord(t[1])]
|
||
elif ord(t[0]) == TLV_CODE_ONIE_VERSION:
|
||
name = "ONIE Version"
|
||
value = t[2 : 2 + ord(t[1])]
|
||
elif ord(t[0]) == TLV_CODE_MAC_SIZE:
|
||
name = "MAC Addresses"
|
||
value = str((ord(t[2]) << 8) | ord(t[3]))
|
||
elif ord(t[0]) == TLV_CODE_MANUF_NAME:
|
||
name = "Manufacturer"
|
||
value = t[2 : 2 + ord(t[1])]
|
||
elif ord(t[0]) == TLV_CODE_MANUF_COUNTRY:
|
||
name = "Manufacture Country"
|
||
value = t[2 : 2 + ord(t[1])]
|
||
elif ord(t[0]) == TLV_CODE_VENDOR_NAME:
|
||
name = "Vendor Name"
|
||
value = t[2 : 2 + ord(t[1])]
|
||
elif ord(t[0]) == TLV_CODE_DIAG_VERSION:
|
||
name = "Diag Version"
|
||
value = t[2 : 2 + ord(t[1])]
|
||
elif ord(t[0]) == TLV_CODE_SERVICE_TAG:
|
||
name = "Service Tag"
|
||
value = t[2 : 2 + ord(t[1])]
|
||
elif ord(t[0]) == TLV_CODE_VENDOR_EXT:
|
||
name = "Vendor Extension"
|
||
value = ""
|
||
if _TLV_DISPLAY_VENDOR_EXT:
|
||
value = t[2 : 2 + ord(t[1])]
|
||
elif ord(t[0]) == TLV_CODE_CRC_32 and len(t) == 6:
|
||
name = "CRC-32"
|
||
value = "0x%08X" % (
|
||
((ord(t[2]) << 24) | (ord(t[3]) << 16) | (ord(t[4]) << 8) | ord(t[5])),
|
||
)
|
||
elif ord(t[0]) == TLV_CODE_RJ_CARID:
|
||
name = "rj_cardid"
|
||
value = ""
|
||
for c in t[2 : 2 + ord(t[1])]:
|
||
value += "%02X" % (ord(c),)
|
||
else:
|
||
name = "Unknown"
|
||
value = ""
|
||
for c in t[2 : 2 + ord(t[1])]:
|
||
value += "0x%02X " % (ord(c),)
|
||
return {"name": name, "code": ord(t[0]), "value": value}
|
||
|
||
|
||
def decode_eeprom(e):
|
||
total_len = (ord(e[9]) << 8) | ord(e[10])
|
||
tlv_index = _TLV_INFO_HDR_LEN
|
||
tlv_end = _TLV_INFO_HDR_LEN + total_len
|
||
ret = []
|
||
while (tlv_index + 2) < len(e) and tlv_index < tlv_end:
|
||
rt = decoder(None, e[tlv_index : tlv_index + 2 + ord(e[tlv_index + 1])])
|
||
ret.append(rt)
|
||
if ord(e[tlv_index]) == TLV_CODE_CRC_32:
|
||
break
|
||
tlv_index += ord(e[tlv_index + 1]) + 2
|
||
for item in ret:
|
||
if item["code"] == TLV_CODE_VENDOR_EXT:
|
||
rt = decoder(None, item["value"][0 : 0 + 2 + ord(item["value"][0 + 1])])
|
||
ret.append(rt)
|
||
return ret
|
||
|
||
|
||
def get_sys_eeprom():
|
||
eeprom = get_sysfs_value(rg_eeprom)
|
||
return decode_eeprom(eeprom)
|
||
|
||
|
||
# get card ID
|
||
def getCardId():
|
||
ret = get_sys_eeprom()
|
||
for item in ret:
|
||
if item["code"] == TLV_CODE_RJ_CARID:
|
||
return item.get("value", None)
|
||
return None
|
||
|
||
|
||
# ====================================
|
||
# execute shell command
|
||
# ====================================
|
||
def os_system(cmd):
|
||
status, output = commands.getstatusoutput(cmd)
|
||
return status, output
|
||
|
||
|
||
###########################################
|
||
# get memory slot and number via DMI command
|
||
###########################################
|
||
def getsysmeminfo():
|
||
ret, log = os_system("which dmidecode ")
|
||
if ret != 0 or len(log) <= 0:
|
||
error = "cmd find dmidecode"
|
||
return False, error
|
||
cmd = log + '|grep -P -A5 "Memory\s+Device"|grep Size|grep -v Range'
|
||
# get total number first
|
||
result = []
|
||
ret1, log1 = os_system(cmd)
|
||
if ret1 == 0 and len(log1):
|
||
log1 = log1.lstrip()
|
||
arr = log1.split("\n")
|
||
# total = len(arr) # total slot number
|
||
for i in range(len(arr)):
|
||
val = re.sub("\D", "", arr[i])
|
||
if val == "":
|
||
val = arr[i].lstrip()
|
||
val = re.sub("Size:", "", val).lstrip()
|
||
# print val
|
||
result.append({"slot": i + 1, "size": val})
|
||
return True, result
|
||
return False, "error"
|
||
|
||
|
||
###########################################
|
||
# get memory slot and number via DMI command
|
||
# return various arrays
|
||
###########################################
|
||
def getsysmeminfo_detail():
|
||
ret, log = os_system("which dmidecode ")
|
||
if ret != 0 or len(log) <= 0:
|
||
error = "cmd find dmidecode"
|
||
return False, error
|
||
cmd = log + ' -t 17 | grep -A21 "Memory Device"' # 17
|
||
# get total number
|
||
ret1, log1 = os_system(cmd)
|
||
if ret1 != 0 or len(log1) <= 0:
|
||
return False, "command execution error[%s]" % cmd
|
||
result_t = log1.split("--")
|
||
mem_rets = []
|
||
for item in result_t:
|
||
its = item.replace("\t", "").strip().split("\n")
|
||
ret = {}
|
||
for it in its:
|
||
if ":" in it:
|
||
key = it.split(":")[0].lstrip()
|
||
value = it.split(":")[1].lstrip()
|
||
ret[key] = value
|
||
mem_rets.append(ret)
|
||
return True, mem_rets
|
||
|
||
|
||
###########################################
|
||
# get BIOS info via DMI command
|
||
###########################################
|
||
def getDmiSysByType(type_t):
|
||
ret, log = os_system("which dmidecode ")
|
||
if ret != 0 or len(log) <= 0:
|
||
error = "cmd find dmidecode"
|
||
return False, error
|
||
cmd = log + " -t %s" % type_t
|
||
# get total number
|
||
ret1, log1 = os_system(cmd)
|
||
if ret1 != 0 or len(log1) <= 0:
|
||
return False, "command execution error[%s]" % cmd
|
||
its = log1.replace("\t", "").strip().split("\n")
|
||
ret = {}
|
||
for it in its:
|
||
if ":" in it:
|
||
key = it.split(":")[0].lstrip()
|
||
value = it.split(":")[1].lstrip()
|
||
ret[key] = value
|
||
return True, ret
|
||
|
||
|
||
def gethwsys():
|
||
return getDmiSysByType(1)
|
||
|
||
|
||
###########################################
|
||
# get BIOS info via DMI command
|
||
|
||
|
||
def getsysbios():
|
||
return getDmiSysByType(0)
|
||
|
||
|
||
def searchDirByName(name, dir):
|
||
result = []
|
||
try:
|
||
files = os.listdir(dir)
|
||
for file in files:
|
||
if name in file:
|
||
result.append(os.path.join(dir, file))
|
||
except Exception as e:
|
||
pass
|
||
return result
|
||
|
||
|
||
def getUsbLocation():
|
||
dir = "/sys/block/"
|
||
spect = "sd"
|
||
usbpath = ""
|
||
result = searchDirByName(spect, dir)
|
||
if len(result) <= 0:
|
||
return False
|
||
for item in result:
|
||
with open(os.path.join(item, "removable"), "r") as fd:
|
||
value = fd.read()
|
||
if value.strip() == "1": # U-Disk found
|
||
usbpath = item
|
||
break
|
||
if usbpath == "": # no U-Disk found
|
||
log_debug("no usb found")
|
||
return False, usbpath
|
||
return True, usbpath
|
||
|
||
|
||
# judge USB file
|
||
def getusbinfo():
|
||
ret, path = getUsbLocation()
|
||
if ret == False:
|
||
return False, "not usb exists"
|
||
str = os.path.join(path, "size")
|
||
ret, value = getfilevalue(str)
|
||
if ret == True:
|
||
return (
|
||
True,
|
||
{
|
||
"id": os.path.basename(path),
|
||
"size": float(value) * 512 / 1024 / 1024 / 1024,
|
||
},
|
||
)
|
||
else:
|
||
return False, "Err"
|
||
|
||
|
||
def get_cpu_info():
|
||
cmd = "cat /proc/cpuinfo |grep processor -A18" # 17
|
||
|
||
ret, log1 = os_system(cmd)
|
||
if ret != 0 or len(log1) <= 0:
|
||
return False, "command execution error[%s]" % cmd
|
||
result_t = log1.split("--")
|
||
mem_rets = []
|
||
for item in result_t:
|
||
its = item.replace("\t", "").strip().split("\n")
|
||
ret = {}
|
||
for it in its:
|
||
if ":" in it:
|
||
key = it.split(":")[0].lstrip()
|
||
value = it.split(":")[1].lstrip()
|
||
ret[key] = value
|
||
mem_rets.append(ret)
|
||
return True, mem_rets
|
||
|
||
|
||
# read file
|
||
def get_version_config_info(attr_key, file_name=None):
|
||
if file_name is None:
|
||
version_conf_filename = "/root/version.json"
|
||
else:
|
||
version_conf_filename = file_name
|
||
if not os.path.isfile(version_conf_filename):
|
||
return None
|
||
with open(version_conf_filename) as rjconf_file:
|
||
for line in rjconf_file:
|
||
tokens = line.split("=")
|
||
if len(tokens) < 2:
|
||
continue
|
||
if tokens[0] == attr_key:
|
||
return tokens[1].strip()
|
||
return None
|
||
|
||
|
||
def io_rd(reg_addr, size=1):
|
||
path = "/dev/port"
|
||
ret = ""
|
||
fd = None
|
||
try:
|
||
reg_addr = int(reg_addr)
|
||
fd = os.open(path, os.O_RDWR|os.O_CREAT)
|
||
for i in range(size):
|
||
os.lseek(fd, reg_addr+i, os.SEEK_SET)
|
||
ret+="{:02x}".format(ord(os.read(fd, 1).decode('latin-1')))
|
||
return ret
|
||
except Exception as e:
|
||
print(str(e))
|
||
return None
|
||
finally:
|
||
if fd: os.close(fd)
|
||
|
||
|
||
def io_wr(reg_addr, reg_data):
|
||
u"""io write"""
|
||
fd = None
|
||
try:
|
||
regdata = 0
|
||
regaddr = 0
|
||
if type(reg_addr) == int:
|
||
regaddr = reg_addr
|
||
else:
|
||
regaddr = int(reg_addr, 16)
|
||
if type(reg_data) == int:
|
||
regdata = reg_data
|
||
else:
|
||
regdata = int(reg_data, 16)
|
||
devfile = "/dev/port"
|
||
fd = os.open(devfile, os.O_RDWR | os.O_CREAT)
|
||
os.lseek(fd, regaddr, os.SEEK_SET)
|
||
os.write(fd, regdata.to_bytes(2, 'little'))
|
||
return True
|
||
except ValueError as e:
|
||
print(e)
|
||
return False
|
||
except Exception as e:
|
||
print(e)
|
||
return False
|
||
finally:
|
||
if fd: os.close(fd)
|