deepblue/ipmitool
1
0
Fork 0
mirror of https://github.com/ipmitool/ipmitool.git synced 2025-05-10 18:47:22 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
ipmitool/lib/ipmi_fwum.c
Zdenek Styblik 6d25903a0b ID: 317 - ipmi_fwum.c: fix typo
2014-05-24 09:18:32 +02:00

1133 lines
31 KiB
C
Raw Blame History

/*
* Copyright (c) 2004 Kontron Canada, Inc. All Rights Reserved.
*
* Base on code from
* Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* Redistribution of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* Redistribution in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of Sun Microsystems, Inc. or the names of
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* This software is provided "AS IS," without a warranty of any kind.
* ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
* INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
* PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
* SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE
* FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
* OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL
* SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,
* OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
* PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
* LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
* EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
*/
#include <string.h>
#include <math.h>
#include <time.h>
#include <unistd.h>
#include <ipmitool/log.h>
#include <ipmitool/helper.h>
#include <ipmitool/ipmi.h>
#include <ipmitool/ipmi_fwum.h>
#include <ipmitool/ipmi_intf.h>
#include <ipmitool/ipmi_mc.h>
extern int verbose;
unsigned char firmBuf[1024*512];
tKFWUM_SaveFirmwareInfo save_fw_nfo;
int KfwumGetFileSize(const char *pFileName,
unsigned long *pFileSize);
int KfwumSetupBuffersFromFile(const char *pFileName,
unsigned long fileSize);
void KfwumShowProgress(const char *task, unsigned long current,
unsigned long total);
unsigned short KfwumCalculateChecksumPadding(unsigned char *pBuffer,
unsigned long totalSize);
int KfwumGetInfo(struct ipmi_intf *intf, unsigned char output,
unsigned char *pNumBank);
int KfwumGetDeviceInfo(struct ipmi_intf *intf,
unsigned char output, tKFWUM_BoardInfo *pBoardInfo);
int KfwumGetStatus(struct ipmi_intf *intf);
int KfwumManualRollback(struct ipmi_intf *intf);
int KfwumStartFirmwareImage(struct ipmi_intf *intf,
unsigned long length, unsigned short padding);
int KfwumSaveFirmwareImage(struct ipmi_intf *intf,
unsigned char sequenceNumber, unsigned long address,
unsigned char *pFirmBuf, unsigned char *pInBufLength);
int KfwumFinishFirmwareImage(struct ipmi_intf *intf,
tKFWUM_InFirmwareInfo firmInfo);
int KfwumUploadFirmware(struct ipmi_intf *intf,
unsigned char *pBuffer, unsigned long totalSize);
int KfwumStartFirmwareUpgrade(struct ipmi_intf *intf);
int KfwumGetInfoFromFirmware(unsigned char *pBuf,
unsigned long bufSize, tKFWUM_InFirmwareInfo *pInfo);
void KfwumFixTableVersionForOldFirmware(tKFWUM_InFirmwareInfo *pInfo);
int KfwumGetTraceLog(struct ipmi_intf *intf);
int ipmi_kfwum_checkfwcompat(tKFWUM_BoardInfo boardInfo,
tKFWUM_InFirmwareInfo firmInfo);
int ipmi_fwum_fwupgrade(struct ipmi_intf *intf, char *file, int action);
int ipmi_fwum_info(struct ipmi_intf *intf);
int ipmi_fwum_status(struct ipmi_intf *intf);
void printf_kfwum_help(void);
void printf_kfwum_info(tKFWUM_BoardInfo boardInfo,
tKFWUM_InFirmwareInfo firmInfo);
/* String table */
/* Must match eFWUM_CmdId */
const char *CMD_ID_STRING[] = {
"GetFwInfo",
"KickWatchdog",
"GetLastAnswer",
"BootHandshake",
"ReportStatus",
"CtrlIPMBLine",
"SetFwState",
"GetFwStatus",
"GetSpiMemStatus",
"StartFwUpdate",
"StartFwImage",
"SaveFwImage",
"FinishFwImage",
"ReadFwImage",
"ManualRollback",
"GetTraceLog"
};
const char *EXT_CMD_ID_STRING[] = {
"FwUpgradeLock",
"ProcessFwUpg",
"ProcessFwRb",
"WaitHSAfterUpg",
"WaitFirstHSUpg",
"FwInfoStateChange"
};
const char *CMD_STATE_STRING[] = {
"Invalid",
"Begin",
"Progress",
"Completed"
};
const struct valstr bankStateValS[] = {
{ 0x00, "Not programmed" },
{ 0x01, "New firmware" },
{ 0x02, "Wait for validation" },
{ 0x03, "Last Known Good" },
{ 0x04, "Previous Good" }
};
/* ipmi_fwum_main - entry point for this ipmitool mode
*
* @intf: ipmi interface
* @arc: number of arguments
* @argv: point to argument array
*
* returns 0 on success
* returns -1 on error
*/
int
ipmi_fwum_main(struct ipmi_intf *intf, int argc, char **argv)
{
int rc = 0;
printf("FWUM extension Version %d.%d\n", VER_MAJOR, VER_MINOR);
if (argc < 1) {
lprintf(LOG_ERR, "Not enough parameters given.");
printf_kfwum_help();
return (-1);
}
if (strncmp(argv[0], "help", 4) == 0) {
printf_kfwum_help();
rc = 0;
} else if (strncmp(argv[0], "info", 4) == 0) {
rc = ipmi_fwum_info(intf);
} else if (strncmp(argv[0], "status", 6) == 0) {
rc = ipmi_fwum_status(intf);
} else if (strncmp(argv[0], "rollback", 8) == 0) {
rc = KfwumManualRollback(intf);
} else if (strncmp(argv[0], "download", 8) == 0) {
if ((argc < 2) || (strlen(argv[1]) < 1)) {
lprintf(LOG_ERR,
"Path and file name must be specified.");
return (-1);
}
printf("Firmware File Name : %s\n", argv[1]);
rc = ipmi_fwum_fwupgrade(intf, argv[1], 0);
} else if (strncmp(argv[0], "upgrade", 7) == 0) {
if ((argc >= 2) && (strlen(argv[1]) > 0)) {
printf("Upgrading using file name %s\n", argv[1]);
rc = ipmi_fwum_fwupgrade(intf, argv[1], 1);
} else {
rc = KfwumStartFirmwareUpgrade(intf);
}
} else if (strncmp(argv[0], "tracelog", 8) == 0) {
rc = KfwumGetTraceLog(intf);
} else {
lprintf(LOG_ERR, "Invalid KFWUM command: %s", argv[0]);
printf_kfwum_help();
rc = (-1);
}
return rc;
}
void
printf_kfwum_help(void)
{
lprintf(LOG_NOTICE,
"KFWUM Commands: info status download upgrade rollback tracelog");
}
/* private definitions and macros */
typedef enum eFWUM_CmdId
{
KFWUM_CMD_ID_GET_FIRMWARE_INFO = 0,
KFWUM_CMD_ID_KICK_IPMC_WATCHDOG = 1,
KFWUM_CMD_ID_GET_LAST_ANSWER = 2,
KFWUM_CMD_ID_BOOT_HANDSHAKE = 3,
KFWUM_CMD_ID_REPORT_STATUS = 4,
KFWUM_CMD_ID_GET_FIRMWARE_STATUS = 7,
KFWUM_CMD_ID_START_FIRMWARE_UPDATE = 9,
KFWUM_CMD_ID_START_FIRMWARE_IMAGE = 0x0a,
KFWUM_CMD_ID_SAVE_FIRMWARE_IMAGE = 0x0b,
KFWUM_CMD_ID_FINISH_FIRMWARE_IMAGE = 0x0c,
KFWUM_CMD_ID_READ_FIRMWARE_IMAGE = 0x0d,
KFWUM_CMD_ID_MANUAL_ROLLBACK = 0x0e,
KFWUM_CMD_ID_GET_TRACE_LOG = 0x0f,
KFWUM_CMD_ID_STD_MAX_CMD,
KFWUM_CMD_ID_EXTENDED_CMD = 0xC0
} tKFWUM_CmdId;
int
ipmi_fwum_info(struct ipmi_intf *intf)
{
tKFWUM_BoardInfo b_info;
int rc = 0;
unsigned char not_used;
if (verbose) {
printf("Getting Kontron FWUM Info\n");
}
if (KfwumGetDeviceInfo(intf, 1, &b_info) != 0) {
rc = (-1);
}
if (KfwumGetInfo(intf, 1, &not_used) != 0) {
rc = (-1);
}
return rc;
}
int
ipmi_fwum_status(struct ipmi_intf *intf)
{
if (verbose) {
printf("Getting Kontron FWUM Status\n");
}
if (KfwumGetStatus(intf) != 0) {
return (-1);
}
return 0;
}
/* ipmi_fwum_fwupgrade - function implements download/upload of the firmware
* data received as parameters
*
* @file: fw file
* @action: 0 = download, 1 = upload/start upload
*
* returns 0 on success, otherwise (-1)
*/
int
ipmi_fwum_fwupgrade(struct ipmi_intf *intf, char *file, int action)
{
tKFWUM_BoardInfo b_info;
tKFWUM_InFirmwareInfo fw_info = { 0 };
unsigned short padding;
unsigned long fsize = 0;
unsigned char not_used;
if (file == NULL) {
lprintf(LOG_ERR, "No file given.");
return (-1);
}
if (KfwumGetFileSize(file, &fsize) != 0) {
return (-1);
}
if (KfwumSetupBuffersFromFile(file, fsize) != 0) {
return (-1);
}
padding = KfwumCalculateChecksumPadding(firmBuf, fsize);
if (KfwumGetInfoFromFirmware(firmBuf, fsize, &fw_info) != 0) {
return (-1);
}
if (KfwumGetDeviceInfo(intf, 0, &b_info) != 0) {
return (-1);
}
if (ipmi_kfwum_checkfwcompat(b_info, fw_info) != 0) {
return (-1);
}
KfwumGetInfo(intf, 0, &not_used);
printf_kfwum_info(b_info, fw_info);
if (KfwumStartFirmwareImage(intf, fsize, padding) != 0) {
return (-1);
}
if (KfwumUploadFirmware(intf, firmBuf, fsize) != 0) {
return (-1);
}
if (KfwumFinishFirmwareImage(intf, fw_info) != 0) {
return (-1);
}
if (KfwumGetStatus(intf) != 0) {
return (-1);
}
if (action != 0) {
if (KfwumStartFirmwareUpgrade(intf) != 0) {
return (-1);
}
}
return 0;
}
/* KfwumGetFileSize - gets the file size
*
* @pFileName : filename ptr
* @pFileSize : output ptr for filesize
*
* returns 0 on success, otherwise (-1)
*/
int
KfwumGetFileSize(const char *pFileName, unsigned long *pFileSize)
{
FILE *pFileHandle = NULL;
pFileHandle = fopen(pFileName, "rb");
if (pFileHandle == NULL) {
return (-1);
}
if (fseek(pFileHandle, 0L , SEEK_END) == 0) {
*pFileSize = ftell(pFileHandle);
}
fclose(pFileHandle);
if (*pFileSize != 0) {
return 0;
}
return (-1);
}
/* KfwumSetupBuffersFromFile - small buffers are used to store the file data
*
* @pFileName : filename ptr
* unsigned long : filesize
*
* returns 0 on success, otherwise (-1)
*/
int
KfwumSetupBuffersFromFile(const char *pFileName, unsigned long fileSize)
{
int rc = (-1);
FILE *pFileHandle = NULL;
int count;
int modulus;
int qty = 0;
pFileHandle = fopen(pFileName, "rb");
if (pFileHandle == NULL) {
lprintf(LOG_ERR, "Failed to open '%s' for reading.",
pFileName);
return (-1);
}
count = fileSize / MAX_BUFFER_SIZE;
modulus = fileSize % MAX_BUFFER_SIZE;
rewind(pFileHandle);
for (qty = 0; qty < count; qty++) {
KfwumShowProgress("Reading Firmware from File",
qty, count);
if (fread(&firmBuf[qty * MAX_BUFFER_SIZE], 1,
MAX_BUFFER_SIZE,
pFileHandle) == MAX_BUFFER_SIZE) {
rc = 0;
}
}
if (modulus) {
if (fread(&firmBuf[qty * MAX_BUFFER_SIZE], 1,
modulus, pFileHandle) == modulus) {
rc = 0;
}
}
if (rc == 0) {
KfwumShowProgress("Reading Firmware from File", 100, 100);
}
fclose(pFileHandle);
return rc;
}
/* KfwumShowProgress - helper routine to display progress bar
*
* Converts current/total in percent
*
* *task : string identifying current operation
* current: progress
* total : limit
*/
void
KfwumShowProgress(const char *task, unsigned long current, unsigned long total)
{
# define PROG_LENGTH 42
static unsigned long staticProgress=0xffffffff;
unsigned char spaces[PROG_LENGTH + 1];
unsigned short hash;
float percent = ((float)current / total);
unsigned long progress = 100 * (percent);
if (staticProgress == progress) {
/* We displayed the same last time.. so don't do it */
return;
}
staticProgress = progress;
printf("%-25s : ", task); /* total 20 bytes */
hash = (percent * PROG_LENGTH);
memset(spaces, '#', hash);
spaces[hash] = '\0';
printf("%s", spaces);
memset(spaces, ' ', (PROG_LENGTH - hash));
spaces[(PROG_LENGTH - hash)] = '\0';
printf("%s", spaces );
printf(" %3ld %%\r", progress); /* total 7 bytes */
if (progress == 100) {
printf("\n");
}
fflush(stdout);
}
/* KfwumCalculateChecksumPadding - TBD
*/
unsigned short
KfwumCalculateChecksumPadding(unsigned char *pBuffer, unsigned long totalSize)
{
unsigned short sumOfBytes = 0;
unsigned short padding;
unsigned long counter;
for (counter = 0; counter < totalSize; counter ++) {
sumOfBytes += pBuffer[counter];
}
padding = 0 - sumOfBytes;
return padding;
}
/* KfwumGetInfo - Get Firmware Update Manager (FWUM) information
*
* *intf : IPMI interface
* output : when set to non zero, queried information is displayed
* pNumBank: output ptr for number of banks
*
* returns 0 on success, otherwise (-1)
*/
int
KfwumGetInfo(struct ipmi_intf *intf, unsigned char output,
unsigned char *pNumBank)
{
int rc = 0;
static struct KfwumGetInfoResp *pGetInfo;
struct ipmi_rs *rsp;
struct ipmi_rq req;
memset(&req, 0, sizeof(req));
req.msg.netfn = IPMI_NETFN_FIRMWARE;
req.msg.cmd = KFWUM_CMD_ID_GET_FIRMWARE_INFO;
req.msg.data_len = 0;
rsp = intf->sendrecv(intf, &req);
if (!rsp) {
lprintf(LOG_ERR, "Error in FWUM Firmware Get Info Command.");
return (-1);
} else if (rsp->ccode != 0) {
lprintf(LOG_ERR, "FWUM Firmware Get Info returned %x",
rsp->ccode);
return (-1);
}
pGetInfo = (struct KfwumGetInfoResp *)rsp->data;
if (output) {
printf("\nFWUM info\n");
printf("=========\n");
printf("Protocol Revision : %02Xh\n",
pGetInfo->protocolRevision);
printf("Controller Device Id : %02Xh\n",
pGetInfo->controllerDeviceId);
printf("Firmware Revision : %u.%u%u",
pGetInfo->firmRev1, pGetInfo->firmRev2 >> 4,
pGetInfo->firmRev2 & 0x0f);
if (pGetInfo->byte.mode != 0) {
printf(" - DEBUG BUILD\n");
} else {
printf("\n");
}
printf("Number Of Memory Bank : %u\n", pGetInfo->numBank);
}
*pNumBank = pGetInfo->numBank;
/* Determine wich type of download to use: */
/* Old FWUM or Old IPMC fw (data_len < 7)
* --> Address with small buffer size
*/
if ((pGetInfo->protocolRevision) <= 0x05 || (rsp->data_len < 7 )) {
save_fw_nfo.downloadType = KFWUM_DOWNLOAD_TYPE_ADDRESS;
save_fw_nfo.bufferSize = KFWUM_SMALL_BUFFER;
save_fw_nfo.overheadSize = KFWUM_OLD_CMD_OVERHEAD;
if (verbose) {
printf("Protocol Revision :");
printf(" <= 5 detected, adjusting buffers\n");
}
} else {
/* Both fw are using the new protocol */
save_fw_nfo.downloadType = KFWUM_DOWNLOAD_TYPE_SEQUENCE;
save_fw_nfo.overheadSize = KFWUM_NEW_CMD_OVERHEAD;
/* Buffer size depending on access type (Local or remote) */
/* Look if we run remote or locally */
if (verbose) {
printf("Protocol Revision :");
printf(" > 5 optimizing buffers\n");
}
if (strstr(intf->name,"lan") != NULL) {
/* also covers lanplus */
save_fw_nfo.bufferSize = KFWUM_SMALL_BUFFER;
if (verbose) {
printf("IOL payload size : %d\n",
save_fw_nfo.bufferSize);
}
} else if ((strstr(intf->name,"open")!= NULL)
&& intf->target_addr != IPMI_BMC_SLAVE_ADDR
&& (intf->target_addr != intf->my_addr)) {
save_fw_nfo.bufferSize = KFWUM_SMALL_BUFFER;
if (verbose) {
printf("IPMB payload size : %d\n",
save_fw_nfo.bufferSize);
}
} else {
save_fw_nfo.bufferSize = KFWUM_BIG_BUFFER;
if (verbose) {
printf("SMI payload size : %d\n",
save_fw_nfo.bufferSize);
}
}
}
return rc;
}
/* KfwumGetDeviceInfo - Get IPMC/Board information
*
* *intf: IPMI interface
* output: when set to non zero, queried information is displayed
* tKFWUM_BoardInfo: output ptr for IPMC/Board information
*
* returns 0 on success, otherwise (-1)
*/
int
KfwumGetDeviceInfo(struct ipmi_intf *intf, unsigned char output,
tKFWUM_BoardInfo *pBoardInfo)
{
struct ipm_devid_rsp *pGetDevId;
struct ipmi_rs *rsp;
struct ipmi_rq req;
/* Send Get Device Id */
memset(&req, 0, sizeof(req));
req.msg.netfn = IPMI_NETFN_APP;
req.msg.cmd = BMC_GET_DEVICE_ID;
req.msg.data_len = 0;
rsp = intf->sendrecv(intf, &req);
if (rsp == NULL) {
lprintf(LOG_ERR, "Error in Get Device Id Command");
return (-1);
} else if (rsp->ccode != 0) {
lprintf(LOG_ERR, "Get Device Id returned %x",
rsp->ccode);
return (-1);
}
pGetDevId = (struct ipm_devid_rsp *)rsp->data;
pBoardInfo->iana = IPM_DEV_MANUFACTURER_ID(pGetDevId->manufacturer_id);
pBoardInfo->boardId = buf2short(pGetDevId->product_id);
if (output) {
printf("\nIPMC Info\n");
printf("=========\n");
printf("Manufacturer Id : %u\n",
pBoardInfo->iana);
printf("Board Id : %u\n",
pBoardInfo->boardId);
printf("Firmware Revision : %u.%u%u",
pGetDevId->fw_rev1, pGetDevId->fw_rev2 >> 4,
pGetDevId->fw_rev2 & 0x0f);
if (((pBoardInfo->iana == IPMI_OEM_KONTRON)
&& (pBoardInfo->boardId = KFWUM_BOARD_KONTRON_5002))) {
printf(" SDR %u", pGetDevId->aux_fw_rev[0]);
}
printf("\n");
}
return 0;
}
/* KfwumGetStatus - Get (and prints) FWUM banks information
*
* *intf : IPMI interface
*
* returns 0 on success, otherwise (-1)
*/
int
KfwumGetStatus(struct ipmi_intf * intf)
{
int rc = 0;
struct ipmi_rs *rsp;
struct ipmi_rq req;
struct KfwumGetStatusResp *pGetStatus;
unsigned char numBank;
unsigned char counter;
unsigned long firmLength;
if (verbose) {
printf(" Getting Status!\n");
}
/* Retreive the number of bank */
rc = KfwumGetInfo(intf, 0, &numBank);
for(counter = 0;
(counter < numBank) && (rc == 0);
counter ++) {
/* Retreive the status of each bank */
memset(&req, 0, sizeof(req));
req.msg.netfn = IPMI_NETFN_FIRMWARE;
req.msg.cmd = KFWUM_CMD_ID_GET_FIRMWARE_STATUS;
req.msg.data = &counter;
req.msg.data_len = 1;
rsp = intf->sendrecv(intf, &req);
if (rsp == NULL) {
lprintf(LOG_ERR,
"Error in FWUM Firmware Get Status Command.");
rc = (-1);
break;
} else if (rsp->ccode) {
lprintf(LOG_ERR,
"FWUM Firmware Get Status returned %x",
rsp->ccode);
rc = (-1);
break;
}
pGetStatus = (struct KfwumGetStatusResp *) rsp->data;
printf("\nBank State %d : %s\n",
counter,
val2str(pGetStatus->bankState, bankStateValS));
if (!pGetStatus->bankState) {
continue;
}
firmLength = pGetStatus->firmLengthMSB;
firmLength = firmLength << 8;
firmLength |= pGetStatus->firmLengthMid;
firmLength = firmLength << 8;
firmLength |= pGetStatus->firmLengthLSB;
printf("Firmware Length : %ld bytes\n",
firmLength);
printf("Firmware Revision : %u.%u%u SDR %u\n",
pGetStatus->firmRev1,
pGetStatus->firmRev2 >> 4,
pGetStatus->firmRev2 & 0x0f,
pGetStatus->firmRev3);
}
printf("\n");
return rc;
}
/* KfwumManualRollback - Ask IPMC to rollback to previous version
*
* *intf : IPMI interface
*
* returns 0 on success
* returns (-1) on error
*/
int
KfwumManualRollback(struct ipmi_intf *intf)
{
struct ipmi_rs *rsp;
struct ipmi_rq req;
struct KfwumManualRollbackReq thisReq;
memset(&req, 0, sizeof(req));
req.msg.netfn = IPMI_NETFN_FIRMWARE;
req.msg.cmd = KFWUM_CMD_ID_MANUAL_ROLLBACK;
thisReq.type = 0; /* Wait BMC shutdown */
req.msg.data = (unsigned char *)&thisReq;
req.msg.data_len = 1;
rsp = intf->sendrecv(intf, &req);
if (rsp == NULL) {
lprintf(LOG_ERR, "Error in FWUM Manual Rollback Command.");
return (-1);
} else if (rsp->ccode != 0) {
lprintf(LOG_ERR,
"Error in FWUM Manual Rollback Command returned %x",
rsp->ccode);
return (-1);
}
printf("FWUM Starting Manual Rollback \n");
return 0;
}
int
KfwumStartFirmwareImage(struct ipmi_intf *intf, unsigned long length,
unsigned short padding)
{
struct ipmi_rs *rsp;
struct ipmi_rq req;
struct KfwumStartFirmwareDownloadResp *pResp;
struct KfwumStartFirmwareDownloadReq thisReq;
thisReq.lengthLSB = length & 0x000000ff;
thisReq.lengthMid = (length >> 8) & 0x000000ff;
thisReq.lengthMSB = (length >> 16) & 0x000000ff;
thisReq.paddingLSB = padding & 0x00ff;
thisReq.paddingMSB = (padding>> 8) & 0x00ff;
thisReq.useSequence = 0x01;
memset(&req, 0, sizeof(req));
req.msg.netfn = IPMI_NETFN_FIRMWARE;
req.msg.cmd = KFWUM_CMD_ID_START_FIRMWARE_IMAGE;
req.msg.data = (unsigned char *) &thisReq;
/* Look for download type */
if (save_fw_nfo.downloadType == KFWUM_DOWNLOAD_TYPE_ADDRESS) {
req.msg.data_len = 5;
} else {
req.msg.data_len = 6;
}
rsp = intf->sendrecv(intf, &req);
if (rsp == NULL) {
lprintf(LOG_ERR,
"Error in FWUM Firmware Start Firmware Image Download Command.");
return (-1);
} else if (rsp->ccode) {
lprintf(LOG_ERR,
"FWUM Firmware Start Firmware Image Download returned %x",
rsp->ccode);
return (-1);
}
pResp = (struct KfwumStartFirmwareDownloadResp *)rsp->data;
printf("Bank holding new firmware : %d\n", pResp->bank);
sleep(5);
return 0;
}
int
KfwumSaveFirmwareImage(struct ipmi_intf *intf, unsigned char sequenceNumber,
unsigned long address, unsigned char *pFirmBuf,
unsigned char *pInBufLength)
{
int rc = 0;
struct ipmi_rs *rsp;
struct ipmi_rq req;
struct KfwumSaveFirmwareAddressReq addr_req;
struct KfwumSaveFirmwareSequenceReq seq_req;
int retry = 0;
int no_rsp = 0;
do {
memset(&req, 0, sizeof(req));
req.msg.netfn = IPMI_NETFN_FIRMWARE;
req.msg.cmd = KFWUM_CMD_ID_SAVE_FIRMWARE_IMAGE;
if (save_fw_nfo.downloadType == KFWUM_DOWNLOAD_TYPE_ADDRESS) {
addr_req.addressLSB = address & 0x000000ff;
addr_req.addressMid = (address >> 8) & 0x000000ff;
addr_req.addressMSB = (address >> 16) & 0x000000ff;
addr_req.numBytes = *pInBufLength;
memcpy(addr_req.txBuf, pFirmBuf, *pInBufLength);
req.msg.data = (unsigned char *)&addr_req;
req.msg.data_len = *pInBufLength + 4;
} else {
seq_req.sequenceNumber = sequenceNumber;
memcpy(seq_req.txBuf, pFirmBuf, *pInBufLength);
req.msg.data = (unsigned char *)&seq_req;
req.msg.data_len = *pInBufLength + sizeof(unsigned char);
/* + 1 => sequenceNumber*/
}
rsp = intf->sendrecv(intf, &req);
if (rsp == NULL) {
lprintf(LOG_ERR,
"Error in FWUM Firmware Save Firmware Image Download Command.");
/* We don't receive "C7" on errors with IOL,
* instead we receive nothing
*/
if (strstr(intf->name, "lan") != NULL) {
no_rsp++;
if (no_rsp < FWUM_SAVE_FIRMWARE_NO_RESPONSE_LIMIT) {
*pInBufLength -= 1;
continue;
}
lprintf(LOG_ERR,
"Error, too many commands without response.");
*pInBufLength = 0;
break;
} /* For other interface keep trying */
} else if (rsp->ccode != 0) {
if (rsp->ccode == 0xc0) {
sleep(1);
} else if ((rsp->ccode == 0xc7)
|| ((rsp->ccode == 0xc3)
&& (sequenceNumber == 0))) {
*pInBufLength -= 1;
retry = 1;
} else if (rsp->ccode == 0x82) {
/* Double sent, continue */
rc = 0;
break;
} else if (rsp->ccode == 0x83) {
if (retry == 0) {
retry = 1;
continue;
}
rc = (-1);
break;
} else if (rsp->ccode == 0xcf) {
/* Ok if receive duplicated request */
retry = 1;
} else if (rsp->ccode == 0xc3) {
if (retry == 0) {
retry = 1;
continue;
}
rc = (-1);
break;
} else {
lprintf(LOG_ERR,
"FWUM Firmware Save Firmware Image Download returned %x",
rsp->ccode);
rc = (-1);
break;
}
} else {
break;
}
} while (1);
return rc;
}
int
KfwumFinishFirmwareImage(struct ipmi_intf *intf, tKFWUM_InFirmwareInfo firmInfo)
{
struct ipmi_rs *rsp;
struct ipmi_rq req;
struct KfwumFinishFirmwareDownloadReq thisReq;
thisReq.versionMaj = firmInfo.versMajor;
thisReq.versionMinSub = ((firmInfo.versMinor <<4)
| firmInfo.versSubMinor);
thisReq.versionSdr = firmInfo.sdrRev;
thisReq.reserved = 0;
/* Byte 4 reserved, write 0 */
memset(&req, 0, sizeof(req));
req.msg.netfn = IPMI_NETFN_FIRMWARE;
req.msg.cmd = KFWUM_CMD_ID_FINISH_FIRMWARE_IMAGE;
req.msg.data = (unsigned char *)&thisReq;
req.msg.data_len = 4;
/* Infinite loop if BMC doesn't reply or replies 0xc0 every time. */
do {
rsp = intf->sendrecv(intf, &req);
} while (rsp == NULL || rsp->ccode == 0xc0);
if (!rsp) {
lprintf(LOG_ERR,
"Error in FWUM Firmware Finish Firmware Image Download Command.");
return (-1);
} else if (rsp->ccode != 0) {
lprintf(LOG_ERR,
"FWUM Firmware Finish Firmware Image Download returned %x",
rsp->ccode);
return (-1);
}
return 0;
}
int
KfwumUploadFirmware(struct ipmi_intf *intf, unsigned char *pBuffer,
unsigned long totalSize)
{
int rc = (-1);
unsigned long address = 0x0;
unsigned char writeSize;
unsigned char oldWriteSize;
unsigned long lastAddress = 0;
unsigned char sequenceNumber = 0;
unsigned char retry = FWUM_MAX_UPLOAD_RETRY;
unsigned char isLengthValid = 1;
do {
writeSize = save_fw_nfo.bufferSize - save_fw_nfo.overheadSize;
/* Reach the end */
if (address + writeSize > totalSize) {
writeSize = (totalSize - address);
} else if (((address % KFWUM_PAGE_SIZE)
+ writeSize) > KFWUM_PAGE_SIZE) {
/* Reach boundary end */
writeSize = (KFWUM_PAGE_SIZE - (address % KFWUM_PAGE_SIZE));
}
oldWriteSize = writeSize;
rc = KfwumSaveFirmwareImage(intf, sequenceNumber,
address, &pBuffer[address], &writeSize);
if ((rc != 0) && (retry-- != 0)) {
address = lastAddress;
rc = 0;
} else if ( writeSize == 0) {
rc = (-1);
} else {
if (writeSize != oldWriteSize) {
printf("Adjusting length to %d bytes \n",
writeSize);
save_fw_nfo.bufferSize -= (oldWriteSize - writeSize);
}
retry = FWUM_MAX_UPLOAD_RETRY;
lastAddress = address;
address+= writeSize;
}
if (rc == 0) {
if ((address % 1024) == 0) {
KfwumShowProgress("Writing Firmware in Flash",
address, totalSize);
}
sequenceNumber++;
}
} while ((rc == 0) && (address < totalSize));
if (rc == 0) {
KfwumShowProgress("Writing Firmware in Flash",
100, 100);
}
return rc;
}
int
KfwumStartFirmwareUpgrade(struct ipmi_intf *intf)
{
int rc = 0;
struct ipmi_rs *rsp;
struct ipmi_rq req;
/* Upgrade type, wait BMC shutdown */
unsigned char upgType = 0 ;
memset(&req, 0, sizeof(req));
req.msg.netfn = IPMI_NETFN_FIRMWARE;
req.msg.cmd = KFWUM_CMD_ID_START_FIRMWARE_UPDATE;
req.msg.data = (unsigned char *) &upgType;
req.msg.data_len = 1;
rsp = intf->sendrecv(intf, &req);
if (rsp == NULL) {
lprintf(LOG_ERR,
"Error in FWUM Firmware Start Firmware Upgrade Command");
rc = (-1);
} else if (rsp->ccode) {
if (rsp->ccode == 0xd5) {
lprintf(LOG_ERR,
"No firmware available for upgrade. Download Firmware first.");
} else {
lprintf(LOG_ERR,
"FWUM Firmware Start Firmware Upgrade returned %x",
rsp->ccode);
}
rc = (-1);
}
return rc;
}
int
KfwumGetTraceLog(struct ipmi_intf *intf)
{
int rc = 0;
struct ipmi_rs *rsp;
struct ipmi_rq req;
unsigned char chunkIdx;
unsigned char cmdIdx;
if (verbose) {
printf(" Getting Trace Log!\n");
}
for (chunkIdx = 0;
(chunkIdx < TRACE_LOG_CHUNK_COUNT)
&& (rc == 0);
chunkIdx++) {
/* Retreive each log chunk and print it */
memset(&req, 0, sizeof(req));
req.msg.netfn = IPMI_NETFN_FIRMWARE;
req.msg.cmd = KFWUM_CMD_ID_GET_TRACE_LOG;
req.msg.data = &chunkIdx;
req.msg.data_len = 1;
rsp = intf->sendrecv(intf, &req);
if (rsp == NULL) {
lprintf(LOG_ERR,
"Error in FWUM Firmware Get Trace Log Command");
rc = (-1);
break;
} else if (rsp->ccode) {
lprintf(LOG_ERR,
"FWUM Firmware Get Trace Log returned %x",
rsp->ccode);
rc = (-1);
break;
}
for (cmdIdx=0; cmdIdx < TRACE_LOG_CHUNK_SIZE; cmdIdx++) {
/* Don't diplay commands with an invalid state */
if ((rsp->data[TRACE_LOG_ATT_COUNT * cmdIdx + 1] != 0)
&& (rsp->data[TRACE_LOG_ATT_COUNT * cmdIdx] < KFWUM_CMD_ID_STD_MAX_CMD)) {
printf(" Cmd ID: %17s -- CmdState: %10s -- CompCode: %2x\n",
CMD_ID_STRING[rsp->data[TRACE_LOG_ATT_COUNT * cmdIdx]],
CMD_STATE_STRING[rsp->data[TRACE_LOG_ATT_COUNT * cmdIdx + 1]],
rsp->data[TRACE_LOG_ATT_COUNT * cmdIdx + 2]);
} else if ((rsp->data[TRACE_LOG_ATT_COUNT * cmdIdx + 1] != 0)
&& (rsp->data[TRACE_LOG_ATT_COUNT*cmdIdx] >= KFWUM_CMD_ID_EXTENDED_CMD)) {
printf(" Cmd ID: %17s -- CmdState: %10s -- CompCode: %2x\n",
EXT_CMD_ID_STRING[rsp->data[TRACE_LOG_ATT_COUNT * cmdIdx] - KFWUM_CMD_ID_EXTENDED_CMD],
CMD_STATE_STRING[rsp->data[TRACE_LOG_ATT_COUNT * cmdIdx + 1]],
rsp->data[TRACE_LOG_ATT_COUNT * cmdIdx + 2]);
}
}
}
printf("\n");
return rc;
}
int
KfwumGetInfoFromFirmware(unsigned char *pBuf, unsigned long bufSize,
tKFWUM_InFirmwareInfo *pInfo)
{
unsigned long offset = 0;
if (bufSize < (IN_FIRMWARE_INFO_OFFSET_LOCATION + IN_FIRMWARE_INFO_SIZE)) {
return (-1);
}
offset = IN_FIRMWARE_INFO_OFFSET_LOCATION;
/* Now, fill the structure with read informations */
pInfo->checksum = (unsigned short)KWUM_GET_BYTE_AT_OFFSET(pBuf,
offset + 0 + IN_FIRMWARE_INFO_OFFSET_CHECKSUM ) << 8;
pInfo->checksum|= (unsigned short)KWUM_GET_BYTE_AT_OFFSET(pBuf,
offset + 1 + IN_FIRMWARE_INFO_OFFSET_CHECKSUM);
pInfo->sumToRemoveFromChecksum = KWUM_GET_BYTE_AT_OFFSET(pBuf,
offset + IN_FIRMWARE_INFO_OFFSET_CHECKSUM);
pInfo->sumToRemoveFromChecksum+= KWUM_GET_BYTE_AT_OFFSET(pBuf,
offset + IN_FIRMWARE_INFO_OFFSET_CHECKSUM + 1);
pInfo->fileSize = KWUM_GET_BYTE_AT_OFFSET(pBuf,
offset + IN_FIRMWARE_INFO_OFFSET_FILE_SIZE + 0) << 24;
pInfo->fileSize|= (unsigned long)KWUM_GET_BYTE_AT_OFFSET(pBuf,
offset + IN_FIRMWARE_INFO_OFFSET_FILE_SIZE + 1) << 16;
pInfo->fileSize|= (unsigned long)KWUM_GET_BYTE_AT_OFFSET(pBuf,
offset + IN_FIRMWARE_INFO_OFFSET_FILE_SIZE + 2) << 8;
pInfo->fileSize|= (unsigned long)KWUM_GET_BYTE_AT_OFFSET(pBuf,
offset + IN_FIRMWARE_INFO_OFFSET_FILE_SIZE + 3);
pInfo->boardId = KWUM_GET_BYTE_AT_OFFSET(pBuf,
offset + IN_FIRMWARE_INFO_OFFSET_BOARD_ID + 0) << 8;
pInfo->boardId|= KWUM_GET_BYTE_AT_OFFSET(pBuf,
offset + IN_FIRMWARE_INFO_OFFSET_BOARD_ID + 1);
pInfo->deviceId = KWUM_GET_BYTE_AT_OFFSET(pBuf,
offset + IN_FIRMWARE_INFO_OFFSET_DEVICE_ID);
pInfo->tableVers = KWUM_GET_BYTE_AT_OFFSET(pBuf,
offset + IN_FIRMWARE_INFO_OFFSET_TABLE_VERSION);
pInfo->implRev = KWUM_GET_BYTE_AT_OFFSET(pBuf,
offset + IN_FIRMWARE_INFO_OFFSET_IMPLEMENT_REV);
pInfo->versMajor = (KWUM_GET_BYTE_AT_OFFSET(pBuf,
offset
+ IN_FIRMWARE_INFO_OFFSET_VER_MAJOROR)) & 0x0f;
pInfo->versMinor = (KWUM_GET_BYTE_AT_OFFSET(pBuf,
offset
+ IN_FIRMWARE_INFO_OFFSET_VER_MINORSUB) >> 4) & 0x0f;
pInfo->versSubMinor = (KWUM_GET_BYTE_AT_OFFSET(pBuf,
offset + IN_FIRMWARE_INFO_OFFSET_VER_MINORSUB)) & 0x0f;
pInfo->sdrRev = KWUM_GET_BYTE_AT_OFFSET(pBuf,
offset + IN_FIRMWARE_INFO_OFFSET_SDR_REV);
pInfo->iana = KWUM_GET_BYTE_AT_OFFSET(pBuf,
offset + IN_FIRMWARE_INFO_OFFSET_IANA2) << 16;
pInfo->iana|= (unsigned long)KWUM_GET_BYTE_AT_OFFSET(pBuf,
offset + IN_FIRMWARE_INFO_OFFSET_IANA1) << 8;
pInfo->iana|= (unsigned long)KWUM_GET_BYTE_AT_OFFSET(pBuf,
offset + IN_FIRMWARE_INFO_OFFSET_IANA0);
KfwumFixTableVersionForOldFirmware(pInfo);
return 0;
}
void
KfwumFixTableVersionForOldFirmware(tKFWUM_InFirmwareInfo * pInfo)
{
switch(pInfo->boardId) {
case KFWUM_BOARD_KONTRON_UNKNOWN:
pInfo->tableVers = 0xff;
break;
default:
/* pInfo->tableVers is already set for
* the right version
*/
break;
}
}
/* ipmi_kfwum_checkfwcompat - check whether firmware we're about to upload is
* compatible with board.
*
* @boardInfo:
* @firmInfo:
*
* returns 0 if compatible, otherwise (-1)
*/
int
ipmi_kfwum_checkfwcompat(tKFWUM_BoardInfo boardInfo,
tKFWUM_InFirmwareInfo firmInfo)
{
int compatible = 0;
if (boardInfo.iana != firmInfo.iana) {
lprintf(LOG_ERR,
"Board IANA does not match firmware IANA.");
compatible = (-1);
}
if (boardInfo.boardId != firmInfo.boardId) {
lprintf(LOG_ERR,
"Board IANA does not match firmware IANA.");
compatible = (-1);
}
if (compatible != 0) {
lprintf(LOG_ERR,
"Firmware invalid for target board. Download of upgrade aborted.");
}
return compatible;
}
void
printf_kfwum_info(tKFWUM_BoardInfo boardInfo, tKFWUM_InFirmwareInfo firmInfo)
{
printf(
"Target Board Id : %u\n", boardInfo.boardId);
printf(
"Target IANA number : %u\n", boardInfo.iana);
printf(
"File Size : %lu bytes\n", firmInfo.fileSize);
printf(
"Firmware Version : %d.%d%d SDR %d\n", firmInfo.versMajor,
firmInfo.versMinor, firmInfo.versSubMinor, firmInfo.sdrRev);
}
Reference in New Issue View Git Blame Copy Permalink