b30cf44b93
Add new platform x86_64-ragile_ra-b6510-48v8c-r0 ASIC Vendor: Broadcom Switch ASIC: Trident 3 Port Config: 48x25G+8x100G Signed-off-by: pettershao-ragilenetworks <pettershao@ragilenetworks.com>
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 cardMAC 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 | ord(s[i])
|
||
return "0x%08x" % val
|
||
|
||
|
||
def rgpciwr(pcibus, slot, fn, bar, offset, data):
|
||
"""write pci register"""
|
||
ret = inttostr(data, 4)
|
||
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 | ord(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, len=1):
|
||
u"""io read"""
|
||
try:
|
||
regaddr = 0
|
||
if type(reg_addr) == int:
|
||
regaddr = reg_addr
|
||
else:
|
||
regaddr = int(reg_addr, 16)
|
||
devfile = "/dev/port"
|
||
fd = os.open(devfile, os.O_RDWR | os.O_CREAT)
|
||
os.lseek(fd, regaddr, os.SEEK_SET)
|
||
str = os.read(fd, len)
|
||
return "".join(["%02x" % ord(item) for item in str])
|
||
except ValueError:
|
||
return None
|
||
except Exception as e:
|
||
print(e)
|
||
return None
|
||
finally:
|
||
os.close(fd)
|
||
|
||
|
||
def io_wr(reg_addr, reg_data):
|
||
u"""io write"""
|
||
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, chr(regdata))
|
||
return True
|
||
except ValueError as e:
|
||
print(e)
|
||
return False
|
||
except Exception as e:
|
||
print(e)
|
||
return False
|
||
finally:
|
||
os.close(fd)
|