#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <time.h>
#include <string.h>
#include <libgen.h>
#include <sys/stat.h>
#include "nvme.h"
#include "nvme-print.h"
#include "nvme-status.h"
#include "nvme-ioctl.h"
#include <sys/ioctl.h>
#include <limits.h>
#define CREATE_CMD
#include "micron-nvme.h"

/* Supported Vendor specific feature ids */
#define MICRON_FEATURE_CLEAR_PCI_CORRECTABLE_ERRORS 0xC3
#define MICRON_FEATURE_CLEAR_FW_ACTIVATION_HISTORY  0xCE
#define MICRON_FEATURE_TELEMETRY_CONTROL_OPTION     0xCF
#define MICRON_FEATURE_SMBUS_OPTION                 0xD5

/* Supported Vendor specific log page sizes */
#define C5_log_size (((452 + 16 * 1024) / 4) * 4096)
#define C0_log_size 512
#define C2_log_size 4096
#define D0_log_size 512
#define FB_log_size 512
#define MaxLogChunk 16 * 1024
#define CommonChunkSize 16 * 4096

#define min(x, y) ((x) > (y) ? (y) : (x))
#define SensorCount 2

/* Plugin version major_number.minor_number.patch */
static const char *__version_major = "1";
static const char *__version_minor = "0";
static const char *__version_patch = "6";

/* supported models of micron plugin; new models should be added at the end
 * before UNKNOWN_MODEL. Make sure M5410 is first in the list !
 */
typedef enum { M5410 = 0, M51AX, M51BX, M51CX, M5407, M5411, UNKNOWN_MODEL } eDriveModel;

#define MICRON_VENDOR_ID 0x1344

static char *fvendorid1 = "/sys/class/nvme/nvme%d/device/vendor";
static char *fvendorid2 = "/sys/class/misc/nvme%d/device/vendor";
static char *fdeviceid1 = "/sys/class/nvme/nvme%d/device/device";
static char *fdeviceid2 = "/sys/class/misc/nvme%d/device/device";
static unsigned short vendor_id;
static unsigned short device_id;

typedef struct _LogPageHeader_t {
    unsigned char numDwordsInLogPageHeaderLo;
    unsigned char logPageHeaderFormatVersion;
    unsigned char logPageId;
    unsigned char numDwordsInLogPageHeaderHi;
    unsigned int numValidDwordsInPayload;
    unsigned int numDwordsInEntireLogPage;
} LogPageHeader_t;

static void WriteData(__u8 *data, __u32 len, const char *dir, const char *file, const char *msg)
{
    char tempFolder[PATH_MAX] = { 0 };
    FILE *fpOutFile = NULL;
    sprintf(tempFolder, "%s/%s", dir, file);
    if ((fpOutFile = fopen(tempFolder, "ab+")) != NULL) {
        if (fwrite(data, 1, len,  fpOutFile) != len) {
            printf("Failed to write %s data to %s\n", msg, tempFolder);
        }
        fclose(fpOutFile);
    } else  {
        printf("Failed to open %s file to write %s\n", tempFolder, msg);
    }
}

static int ReadSysFile(const char *file, unsigned short *id)
{
    int ret = 0;
    char idstr[32] = { '\0' };
    int fd = open(file, O_RDONLY);

    if (fd > 0) {
        ret = read(fd, idstr, sizeof(idstr));
        close(fd);
    }

    if (fd < 0 || ret < 0)
        perror(file);
    else
        *id = strtol(idstr, NULL, 16);

    return ret;
}

static eDriveModel GetDriveModel(int idx)
{
    eDriveModel eModel = UNKNOWN_MODEL;
    char path[512];

    sprintf(path, fvendorid1, idx);
    if (ReadSysFile(path, &vendor_id) < 0) {
        sprintf(path, fvendorid2, idx);
        ReadSysFile(path, &vendor_id);
    }
    sprintf(path, fdeviceid1, idx);
    if (ReadSysFile(path, &device_id) < 0) {
        sprintf(path, fdeviceid2, idx);
        ReadSysFile(path, &device_id);
    }
    if (vendor_id == MICRON_VENDOR_ID) {
        switch (device_id) {
        case 0x51A0:
        case 0x51A1:
        case 0x51A2:
            eModel = M51AX;
            break;
        case 0x51B0:
        case 0x51B1:
        case 0x51B2:
            eModel = M51BX;
            break;
        case 0x51C0:
        case 0x51C1:
        case 0x51C2:
        case 0x51C3:
            eModel = M51CX;
            break;
        case 0x5405:
        case 0x5406:
        case 0x5407:
            eModel = M5407;
            break;
        case 0x5410:
            eModel = M5410;
            break;
        case 0x5411:
            eModel = M5411;
            break;
        default:
            break;
        }
    }
    return eModel;
}

static int ZipAndRemoveDir(char *strDirName, char *strFileName)
{
    int  err = 0;
    char strBuffer[PATH_MAX];
    int  nRet;
    bool is_tgz = false;
    struct stat sb;

    if (strstr(strFileName, ".tar.gz") || strstr(strFileName, ".tgz")) {
        sprintf(strBuffer, "tar -zcf \"%s\" \"%s\"", strFileName,
                strDirName);
        is_tgz = true;
    } else {
        sprintf(strBuffer, "zip -r \"%s\" \"%s\" >temp.txt 2>&1", strFileName,
                strDirName);
    }

    err = EINVAL;
    nRet = system(strBuffer);

    /* check if log file is created, if not print error message */
    if (nRet < 0 || (stat(strFileName, &sb) == -1)) {
        if (is_tgz)
            sprintf(strBuffer, "check if tar and gzip commands are installed");
        else
            sprintf(strBuffer, "check if zip command is installed");

        fprintf(stderr, "Failed to create log data package, %s!\n", strBuffer);
    }

    sprintf(strBuffer, "rm -f -R \"%s\" >temp.txt 2>&1", strDirName);
    nRet = system(strBuffer);
    if (nRet < 0)
        printf("Failed to remove temporary files!\n");

    err = system("rm -f temp.txt");
    return err;
}

static int SetupDebugDataDirectories(char *strSN, char *strFilePath,
                                     char *strMainDirName, char *strOSDirName,
                                     char *strCtrlDirName)
{
    int err = 0;
    char strAppend[250];
    struct stat st;
    char *fileLocation = NULL;
    char *fileName;
    int length = 0;
    int nIndex = 0;
    char *strTemp = NULL;
    struct stat dirStat;
    int j;
    int k = 0;
    int i = 0;

    if (strchr(strFilePath, '/') != NULL) {
        fileName = strrchr(strFilePath, '\\');
        if (fileName == NULL) {
            fileName = strrchr(strFilePath, '/');
        }

        if (fileName != NULL) {
            if (!strcmp(fileName, "/")) {
                goto exit_status;
            }

            while (strFilePath[nIndex] != '\0') {
                if ('\\' == strFilePath[nIndex] && '\\' == strFilePath[nIndex + 1]) {
                    goto exit_status;
                }
                nIndex++;
            }

            length = (int)strlen(strFilePath) - (int)strlen(fileName);

            if (fileName == strFilePath) {
                length = 1;
            }

            if ((fileLocation = (char *)malloc(length + 1)) == NULL) {
                goto exit_status;
            }
            strncpy(fileLocation, strFilePath, length);
            fileLocation[length] = '\0';

            while (fileLocation[k] != '\0') {
                if (fileLocation[k] == '\\') {
                    fileLocation[k] = '/';
                }
                k++;
            }

            length = (int)strlen(fileLocation);

            if (':' == fileLocation[length - 1]) {
                if ((strTemp = (char *)malloc(length + 2)) == NULL) {
                    goto exit_status;
                }
                strcpy(strTemp, fileLocation);
                strcat(strTemp, "/");
                free(fileLocation);

                length = (int)strlen(strTemp);
                if ((fileLocation = (char *)malloc(length + 1)) == NULL) {
                    goto exit_status;
                }

                memcpy(fileLocation, strTemp, length + 1);
                free(strTemp);
            }

            if (stat(fileLocation, &st) != 0) {
                free(fileLocation);
                goto exit_status;
            }
            free(fileLocation);
        } else {
            goto exit_status;
        }
    }

    nIndex = 0;
    for (i = 0; i < (int)strlen(strSN); i++) {
        if (strSN[i] != ' ' && strSN[i] != '\n' && strSN[i] != '\t' && strSN[i] != '\r') {
            strMainDirName[nIndex++] = strSN[i];
        }
    }
    strMainDirName[nIndex] = '\0';

    j = 1;
    while (stat(strMainDirName, &dirStat) == 0) {
        strMainDirName[nIndex] = '\0';
        sprintf(strAppend, "-%d", j);
        strcat(strMainDirName, strAppend);
        j++;
    }

    mkdir(strMainDirName, 0777);

    if (strOSDirName != NULL) {
        sprintf(strOSDirName, "%s/%s", strMainDirName, "OS");
        mkdir(strOSDirName, 0777);

    }
    if (strCtrlDirName != NULL) {
        sprintf(strCtrlDirName, "%s/%s", strMainDirName, "Controller");
        mkdir(strCtrlDirName, 0777);

    }

exit_status:
    return err;
}

static int GetLogPageSize(int nFD, unsigned char ucLogID, int *nLogSize)
{
    int err = 0;
    unsigned char pTmpBuf[CommonChunkSize] = { 0 };
    LogPageHeader_t *pLogHeader = NULL;

    if (ucLogID == 0xC1 || ucLogID == 0xC2 || ucLogID == 0xC4) {
        err = nvme_get_log(nFD, NVME_NSID_ALL, ucLogID, false, NVME_NO_LOG_LSP,
                           CommonChunkSize, pTmpBuf);
        if (err == 0) {
            pLogHeader = (LogPageHeader_t *) pTmpBuf;
            LogPageHeader_t *pLogHeader1 = (LogPageHeader_t *) pLogHeader;
            *nLogSize = (int)(pLogHeader1->numDwordsInEntireLogPage) * 4;
            if (pLogHeader1->logPageHeaderFormatVersion == 0) {
                printf ("Unsupported log page format version %d of log page : 0x%X\n",
                         ucLogID, err);
                *nLogSize = 0;
                err = -1;
            }
        } else {
            printf ("Getting size of log page : 0x%X failed with %d\n", ucLogID, err);
            *nLogSize = 0;
        }
    }
    return err;
}

static int NVMEGetLogPage(int nFD, unsigned char ucLogID, unsigned char *pBuffer, int nBuffSize)
{
    int err = 0;
    struct nvme_admin_cmd cmd = { 0 };
    unsigned int uiNumDwords = (unsigned int)nBuffSize / sizeof(unsigned int);
    unsigned int uiMaxChunk = uiNumDwords;
    unsigned int uiNumChunks = 1;
    unsigned int uiXferDwords = 0;
    unsigned long long ullBytesRead = 0;
    unsigned char *pTempPtr = pBuffer;
    unsigned char ucOpCode = 0x02;

    if (ullBytesRead == 0 && (ucLogID == 0xE6 || ucLogID == 0xE7)) {
        uiMaxChunk = 4096;
    } else if (uiMaxChunk > 16 * 1024) {
        uiMaxChunk = 16 * 1024;
    }

    uiNumChunks = uiNumDwords / uiMaxChunk;
    if (uiNumDwords % uiMaxChunk > 0) {
        uiNumChunks += 1;
    }

    for (unsigned int i = 0; i < uiNumChunks; i++) {
        memset(&cmd, 0, sizeof(cmd));
        uiXferDwords = uiMaxChunk;
        if (i == uiNumChunks - 1 && uiNumDwords % uiMaxChunk > 0) {
            uiXferDwords = uiNumDwords % uiMaxChunk;
        }

        cmd.opcode = ucOpCode;
        cmd.cdw10 |= ucLogID;
        cmd.cdw10 |= ((uiXferDwords - 1) & 0x0000FFFF) << 16;

        if (ucLogID == 0x7) {
            cmd.cdw10 |= 0x80;
        }
        if (ullBytesRead == 0 && (ucLogID == 0xE6 || ucLogID == 0xE7)) {
            cmd.cdw11 = 1;
        }
        if (ullBytesRead > 0 && !(ucLogID == 0xE6 || ucLogID == 0xE7)) {
            unsigned long long ullOffset = ullBytesRead;
            cmd.cdw12 = ullOffset & 0xFFFFFFFF;
            cmd.cdw13 = (ullOffset >> 32) & 0xFFFFFFFF;
        }

        cmd.addr = (__u64) (uintptr_t) pTempPtr;
        cmd.nsid = 0xFFFFFFFF;
        cmd.data_len = uiXferDwords * 4;
        err = nvme_submit_passthru(nFD, NVME_IOCTL_ADMIN_CMD, &cmd);
        ullBytesRead += uiXferDwords * 4;
        pTempPtr = pBuffer + ullBytesRead;
    }

    return err;
}

static int NVMEResetLog(int nFD, unsigned char ucLogID, int nBufferSize,
                        long long llMaxSize)
{
    unsigned int *pBuffer = NULL;
    int err = 0;

    if ((pBuffer = (unsigned int *)calloc(1, nBufferSize)) == NULL)
        return err;

    while (err == 0 && llMaxSize > 0) {
        err = NVMEGetLogPage(nFD, ucLogID, (unsigned char *)pBuffer, nBufferSize);
        if (err)
            return err;

        if (pBuffer[0] == 0xdeadbeef)
            break;

        llMaxSize = llMaxSize - nBufferSize;
    }

    free(pBuffer);
    return err;
}

static int GetCommonLogPage(int nFD, unsigned char ucLogID,
                            unsigned char **pBuffer, int nBuffSize)
{
    unsigned char *pTempPtr = NULL;
    int err = 0;
    pTempPtr = (unsigned char *)malloc(nBuffSize);
    if (!pTempPtr) {
        goto exit_status;
    }
    memset(pTempPtr, 0, nBuffSize);
    err = nvme_get_log(nFD, NVME_NSID_ALL, ucLogID, false, NVME_NO_LOG_LSP,
                       nBuffSize, pTempPtr);
    *pBuffer = pTempPtr;

exit_status:
    return err;
}

/*
 * Plugin Commands
 */
static int micron_parse_options(int argc, char **argv, const char *desc,
    const struct argconfig_commandline_options *opts, eDriveModel *modelp)
{
    int idx = 0;
    int fd = parse_and_open(argc, argv, desc, opts);

    if (fd < 0) {
        perror("open");
        return -1;
    }

    if (modelp) {
        sscanf(argv[optind], "/dev/nvme%d", &idx);
        *modelp = GetDriveModel(idx);
    }

    return fd;
}

static int micron_fw_commit(int fd, int select)
{
    struct nvme_admin_cmd cmd = {
        .opcode = nvme_admin_activate_fw,
        .cdw10 = 8,
        .cdw12 = select,
    };
    return ioctl(fd, NVME_IOCTL_ADMIN_CMD, &cmd);
}

static int micron_selective_download(int argc, char **argv,
                                     struct command *cmd, struct plugin *plugin)
{
    const char *desc =
        "This performs a selective firmware download, which allows the user to "
        "select which firmware binary to update for 9200 devices. This requires "
        "a power cycle once the update completes. The options available are: \n\n"
        "OOB - This updates the OOB and main firmware\n"
        "EEP - This updates the eeprom and main firmware\n"
        "ALL - This updates the eeprom, OOB, and main firmware";
    const char *fw = "firmware file (required)";
    const char *select = "FW Select (e.g., --select=ALL)";
    int xfer = 4096;
    void *fw_buf;
    int fd, selectNo, fw_fd, fw_size, err, offset = 0;
    struct stat sb;

    struct config {
        char *fw;
        char *select;
    };

    struct config cfg = {
        .fw = "",
        .select = "\0",
    };

    OPT_ARGS(opts) = {
        OPT_STRING("fw", 'f', "FILE", &cfg.fw, fw),
        OPT_STRING("select", 's', "flag", &cfg.select, select),
        OPT_END()
    };

    fd = parse_and_open(argc, argv, desc, opts);

    if (fd < 0)
        return fd;

    if (strlen(cfg.select) != 3) {
        fprintf(stderr, "Invalid select flag\n");
        err = EINVAL;
        goto out;
    }

    for (int i = 0; i < 3; i++) {
        cfg.select[i] = toupper(cfg.select[i]);
    }

    if (strncmp(cfg.select, "OOB", 3) == 0) {
        selectNo = 18;
    } else if (strncmp(cfg.select, "EEP", 3) == 0) {
        selectNo = 10;
    } else if (strncmp(cfg.select, "ALL", 3) == 0) {
        selectNo = 26;
    } else {
        fprintf(stderr, "Invalid select flag\n");
        err = EINVAL;
        goto out;
    }

    fw_fd = open(cfg.fw, O_RDONLY);
    if (fw_fd < 0) {
        fprintf(stderr, "no firmware file provided\n");
        err = EINVAL;
        goto out;
    }

    err = fstat(fw_fd, &sb);
    if (err < 0) {
        perror("fstat");
        err = errno;
    }

    fw_size = sb.st_size;
    if (fw_size & 0x3) {
        fprintf(stderr, "Invalid size:%d for f/w image\n", fw_size);
        err = EINVAL;
        goto out;
    }

    if (posix_memalign(&fw_buf, getpagesize(), fw_size)) {
        fprintf(stderr, "No memory for f/w size:%d\n", fw_size);
        err = ENOMEM;
        goto out;
    }

    if (read(fw_fd, fw_buf, fw_size) != ((ssize_t) (fw_size)))
        return EIO;

    while (fw_size > 0) {
        xfer = min(xfer, fw_size);

        err = nvme_fw_download(fd, offset, xfer, fw_buf);
        if (err < 0) {
            perror("fw-download");
            goto out;
        } else if (err != 0) {
            fprintf(stderr, "NVME Admin command error:%s(%x)\n",
                    nvme_status_to_string(err), err);
            goto out;
        }
        fw_buf += xfer;
        fw_size -= xfer;
        offset += xfer;
    }

    err = micron_fw_commit(fd, selectNo);

    if (err == 0x10B || err == 0x20B) {
        err = 0;
        fprintf(stderr,
                "Update successful! Power cycle for changes to take effect\n");
    }

out:
    return err;
}

static int micron_smbus_option(int argc, char **argv,
                               struct command *cmd, struct plugin *plugin)
{
    __u32 result = 0;
    __u32 cdw10 = 0;
    __u32 cdw11 = 0;
    const char *desc = "Enable/Disable/Get status of SMBUS option on controller";
    const char *option = "enable or disable or status";
    const char *value = "1 - hottest component temperature, 0 - composite "
                        "temperature (default) for enable option, 0 (current), "
                        "1 (default), 2 (saved) for status options";
    const char *save = "1 - persistent, 0 - non-persistent (default)";
    int err = 0;
    int fd = 0;
    int fid = MICRON_FEATURE_SMBUS_OPTION;
    eDriveModel model = UNKNOWN_MODEL;

    struct {
        char *option;
        int  value;
        int  save;
        int  status;
    } opt = {
        .option = "disable",
        .value = 0,
        .save = 0,
        .status = 0,
    };

    OPT_ARGS(opts) = {
        OPT_STRING("option", 'o', "option", &opt.option, option),
        OPT_UINT("value", 'v',  &opt.value, value),
        OPT_UINT("save", 's', &opt.save, save),
        OPT_END()
    };

    if ((fd = micron_parse_options(argc, argv, desc, opts, &model)) < 0)
        return err;

    if (model != M5407 && model != M5411) {
        printf ("This option is not supported for specified drive\n");
        close(fd);
        return err;
    }

    if (!strcmp(opt.option, "enable")) {
        cdw11 = opt.value << 1 | 1;
        err = nvme_set_feature(fd, 1, fid, cdw11, 0, opt.save, 0, 0, 0, &result);
        if (err == 0) {
            printf("successfully enabled SMBus on drive\n");
        } else {
            printf("Failed to enabled SMBus on drive\n");
        }
    }
    else if (!strcmp(opt.option, "status")) {
        cdw10 = opt.value;
        err = nvme_get_feature(fd, 1, fid, cdw10, 0, 0, 0, 0, &result);
        if (err == 0) {
            printf("SMBus status on the drive: %s (returns %s temperature) \n",
                    (result & 1) ? "enabled" : "disabled",
                    (result & 2) ? "hottest component" : "composite");
        } else {
            printf("Failed to retrieve SMBus status on the drive\n");
        }
    }
    else if (!strcmp(opt.option, "disable")) {
        cdw11 = opt.value << 1 | 0;
        err = nvme_set_feature(fd, 1, fid, cdw11, 0, opt.save, 0, 0, 0, &result);
        if (err == 0) {
            printf("Successfully disabled SMBus on drive\n");
        } else {
            printf("Failed to disable SMBus on drive\n");
        }
    } else {
        printf("Invalid option %s, valid values are enable, disable or status\n",
                opt.option);
        close(fd);
        return -1;
    }

    close(fd);
    return err;
}

static int micron_temp_stats(int argc, char **argv, struct command *cmd,
                             struct plugin *plugin)
{

    struct nvme_smart_log smart_log;
    unsigned int temperature = 0, i = 0, err = 0;
    unsigned int tempSensors[SensorCount] = { 0 };
    const char *desc = "Retrieve Micron temperature info for the given device ";
    const char *fmt = "output format normal|json";
    struct format {
        char *fmt;
    };
    struct format cfg = {
        .fmt = "normal",
    };
    bool is_json = false;
    struct json_object *root;
    struct json_object *logPages;
    int fd;

    OPT_ARGS(opts) = {
        OPT_FMT("format", 'f', &cfg.fmt, fmt),
        OPT_END()
    };

    fd = parse_and_open(argc, argv, desc, opts);
    if (fd < 0) {
        printf("\nDevice not found \n");;
        return -1;
    }

    if (strcmp(cfg.fmt, "json") == 0)
        is_json = true;

    err = nvme_smart_log(fd, 0xffffffff, &smart_log);
    if (!err) {
        temperature = ((smart_log.temperature[1] << 8) | smart_log.temperature[0]);
        temperature = temperature ? temperature - 273 : 0;
        for (i = 0; i < SensorCount; i++) {
            tempSensors[i] = le16_to_cpu(smart_log.temp_sensor[i]);
            tempSensors[i] = tempSensors[i] ? tempSensors[i] - 273 : 0;
        }
        if (is_json) {
            struct json_object *stats = json_create_object();
            char tempstr[64] = { 0 };
            root = json_create_object();
            logPages = json_create_array();
            json_object_add_value_array(root, "Micron temperature information", logPages);
            sprintf(tempstr, "%u C", temperature);
            json_object_add_value_string(stats, "Current Composite Temperature", tempstr);
            for (i = 0; i < SensorCount; i++) {
                char sensor_str[256] = { 0 };
                char datastr[64] = { 0 };
                sprintf(sensor_str, "Temperature Sensor #%d", (i + 1));
                sprintf(datastr, "%u C", tempSensors[i]);
                json_object_add_value_string(stats, sensor_str, datastr);
            }
            json_array_add_value_object(logPages, stats);
            json_print_object(root, NULL);
            printf("\n");
            json_free_object(root);
        } else {
            printf("Micron temperature information:\n");
            printf("%-10s : %u C\n", "Current Composite Temperature", temperature);
            for (i = 0; i < SensorCount; i++) {
                printf("%-10s%d : %u C\n", "Temperature Sensor #", i + 1, tempSensors[i]);
            }
        }
    }
    return err;
}

static int micron_pcie_stats(int argc, char **argv,
                             struct command *cmd, struct plugin *plugin)
{
    int  i, fd, err = 0, bus = 0, domain = 0, device = 0, function = 0, ctrlIdx;
    char strTempFile[1024], strTempFile2[1024], command[1024];
    char *businfo = NULL;
    char *devicename = NULL;
    char tdevice[NAME_MAX] = { 0 };
    ssize_t sLinkSize = 0;
    FILE *fp;
    char correctable[8] = { 0 };
    char uncorrectable[8] = { 0 };
    eDriveModel eModel = UNKNOWN_MODEL;
    char *res;
    bool is_json = true;
    struct format {
        char *fmt;
    };
    const char *desc = "Retrieve PCIe event counters";
    const char *fmt = "output format json|normal";
    struct format cfg = {
        .fmt = "json",
    };
    struct {
        char *err;
        int  bit;
        int  val;
    } pcie_correctable_errors[] = {
        { "Unsupported Request Error Status (URES)", 20},
        { "ECRC Error Status (ECRCES)", 19},
        { "Malformed TLP Status (MTS)", 18},
        { "Receiver Overflow Status (ROS)", 17},
        { "Unexpected Completion Status (UCS)", 16},
        { "Completer Abort Status (CAS)", 15},
        { "Completion Timeout Stats (CTS)", 14},
        { "Flow Control Protocol Error Status (FCPES)", 13},
        { "Poisoned TLP Status (PTS)", 12},
        { "Data Link Protocol Error Status (DLPES)", 4},
    },
    pcie_uncorrectable_errors[] = {
        { "Advisory Non-Fatal Error Status (ANFES)", 13},
        { "Replay Timer Timeout Status (RTS)",  12},
        { "REPLY NUM Rollover Status (RRS)", 8},
        { "Bad DLLP Status (BDS)", 7},
        { "Bad TLP Status (BTS)", 6},
        { "Receiver Error Status (RES)", 0},
    };

    __u32 correctable_errors;
    __u32 uncorrectable_errors;

    OPT_ARGS(opts) = {
        OPT_FMT("format", 'f', &cfg.fmt, fmt),
        OPT_END()
    };

    fd = parse_and_open(argc, argv, desc, opts);
    if (fd < 0) {
        printf("\nDevice not found \n");;
        return -1;
    }

    /* pull log details based on the model name */
    sscanf(argv[optind], "/dev/nvme%d", &ctrlIdx);
    if ((eModel = GetDriveModel(ctrlIdx)) == UNKNOWN_MODEL) {
        printf ("Unsupported drive model for vs-pcie-stats command\n");
        close(fd);
        goto out;
    }

    if (strcmp(cfg.fmt, "normal") == 0)
        is_json = false;

    if (strstr(argv[optind], "/dev/nvme") && strstr(argv[optind], "n1")) {
        devicename = strrchr(argv[optind], '/');
    } else if (strstr(argv[optind], "/dev/nvme")) {
        devicename = strrchr(argv[optind], '/');
        sprintf(tdevice, "%s%s", devicename, "n1");
        devicename = tdevice;
    } else {
        printf("Invalid device specified!\n");
        goto out;
    }
    sprintf(strTempFile, "/sys/block/%s/device", devicename);
    sLinkSize = readlink(strTempFile, strTempFile2, 1024);
    if (sLinkSize < 0) {
        err = -errno;
        printf("Failed to read device\n");
        goto out;
    }
    if (strstr(strTempFile2, "../../nvme")) {
        sprintf(strTempFile, "/sys/block/%s/device/device", devicename);
        sLinkSize = readlink(strTempFile, strTempFile2, 1024);
        if (sLinkSize < 0) {
            err = -errno;
            printf("Failed to read device\n");
            goto out;
        }
    }
    businfo = strrchr(strTempFile2, '/');
    sscanf(businfo, "/%x:%x:%x.%x", &domain, &bus, &device, &function);
    sprintf(command, "setpci -s %x:%x.%x ECAP_AER+10.L", bus, device,
            function);
    fp = popen(command, "r");
    if (fp == NULL) {
        printf("Failed to retrieve error count\n");
        goto out;
    }
    res = fgets(correctable, sizeof(correctable), fp);
    if (res == NULL) {
        printf("Failed to retrieve error count\n");
        goto out;
    }
    pclose(fp);

    sprintf(command, "setpci -s %x:%x.%x ECAP_AER+0x4.L", bus, device,
            function);
    fp = popen(command, "r");
    if (fp == NULL) {
        printf("Failed to retrieve error count\n");
        goto out;
    }
    res = fgets(uncorrectable, sizeof(uncorrectable), fp);
    if (res == NULL) {
        printf("Failed to retrieve error count\n");
        goto out;
    }
    pclose(fp);

    correctable_errors = (__u32)strtol(correctable, NULL, 16);
    uncorrectable_errors = (__u32)strtol(uncorrectable, NULL, 16);

    if (is_json) {

        struct json_object *root = json_create_object();
        struct json_object *pcieErrors = json_create_array();
        struct json_object *stats = json_create_object();

        json_object_add_value_array(root, "PCIE Stats", pcieErrors);
        for (i = 0; i < sizeof(pcie_correctable_errors) / sizeof(pcie_correctable_errors[0]); i++) {
            json_object_add_value_int(stats, pcie_correctable_errors[i].err,
                                      ((correctable_errors >> pcie_correctable_errors[i].bit) & 1));
        }
        for (i = 0; i < sizeof(pcie_uncorrectable_errors) / sizeof(pcie_uncorrectable_errors[0]); i++) {
            json_object_add_value_int(stats, pcie_uncorrectable_errors[i].err,
                                      ((uncorrectable_errors >> pcie_uncorrectable_errors[i].bit) & 1));
        }
        json_array_add_value_object(pcieErrors, stats);
        json_print_object(root, NULL);
        printf("\n");
        json_free_object(root);
    } else if (eModel == M5407 || eModel == M5410) {
        for (i = 0; i < sizeof(pcie_correctable_errors) / sizeof(pcie_correctable_errors[0]); i++) {
            printf("%-40s : %-1d\n", pcie_correctable_errors[i].err,
                                      ((correctable_errors >> pcie_correctable_errors[i].bit) & 1));
        }
        for (i = 0; i < sizeof(pcie_uncorrectable_errors) / sizeof(pcie_uncorrectable_errors[0]); i++) {
            printf("%-40s : %-1d\n", pcie_uncorrectable_errors[i].err,
                                      ((uncorrectable_errors >> pcie_uncorrectable_errors[i].bit) & 1));
        }
    } else {
        printf("PCIE Stats:\n");
        printf("Device correctable errors detected: %s\n", correctable);
        printf("Device uncorrectable errors detected: %s\n", uncorrectable);
    }

out:
    return err;
}

static int micron_clear_pcie_correctable_errors(int argc, char **argv,
        struct command *cmd,
        struct plugin *plugin)
{
    int err = -EINVAL, bus = 0, domain = 0, device = 0, function = 0;
    char strTempFile[1024], strTempFile2[1024], command[1024];
    char *businfo = NULL;
    char *devicename = NULL;
    char tdevice[PATH_MAX] = { 0 };
    ssize_t sLinkSize = 0;
    eDriveModel model = UNKNOWN_MODEL;
    char correctable[8] = { 0 };
    int  fd = -1;
    FILE *fp;
    char *res;
    const char *desc = "Clear PCIe Device Correctable Errors";
    __u32 result = 0;
    __u8 fid = MICRON_FEATURE_CLEAR_PCI_CORRECTABLE_ERRORS;
    OPT_ARGS(opts) = {
        OPT_END()
    };

    if ((fd = micron_parse_options(argc, argv, desc, opts, &model)) < 0)
        return err;

    /* For M51CX models, PCIe errors are cleared using 0xC3 feature */
    if (model == M51CX) {
        err = nvme_set_feature(fd, 0, fid, (1 << 31), 0, 0, 0, 0, 0, &result);
        if (err == 0 && (err = (int)result) == 0)
            printf("Device correctable errors cleared!\n");
        else if (err > 0)
            nvme_show_status(err);
        else
            printf("Error clearing Device correctable errors = 0x%x\n", err);
        goto out;
    }

    if (strstr(argv[optind], "/dev/nvme") && strstr(argv[optind], "n1")) {
        devicename = strrchr(argv[optind], '/');
    } else if (strstr(argv[optind], "/dev/nvme")) {
        devicename = strrchr(argv[optind], '/');
        sprintf(tdevice, "%s%s", devicename, "n1");
        devicename = tdevice;
    } else {
        printf("Invalid device specified!\n");
        goto out;
    }
    err = snprintf(strTempFile, sizeof(strTempFile),
                   "/sys/block/%s/device", devicename);
    if (err < 0)
        goto out;

    sLinkSize = readlink(strTempFile, strTempFile2, 1024);
    if (sLinkSize < 0) {
        err = -errno;
        printf("Failed to read device\n");
        goto out;
    }
    if (strstr(strTempFile2, "../../nvme")) {
        err = snprintf(strTempFile, sizeof(strTempFile),
                       "/sys/block/%s/device/device", devicename);
        if (err < 0)
            goto out;
        sLinkSize = readlink(strTempFile, strTempFile2, 1024);
        if (sLinkSize < 0) {
            err = -errno;
            printf("Failed to read device\n");
            goto out;
        }
    }
    businfo = strrchr(strTempFile2, '/');
    sscanf(businfo, "/%x:%x:%x.%x", &domain, &bus, &device, &function);
    sprintf(command, "setpci -s %x:%x.%x ECAP_AER+0x10.L=0xffffffff", bus,
            device, function);
    err = -1;
    fp = popen(command, "r");
    if (fp == NULL) {
        printf("Failed to clear error count\n");
        goto out;
    }
    pclose(fp);

    sprintf(command, "setpci -s %x:%x.%x ECAP_AER+0x10.L", bus, device,
            function);
    fp = popen(command, "r");
    if (fp == NULL) {
        printf("Failed to retrieve error count\n");
        goto out;
    }
    res = fgets(correctable, sizeof(correctable), fp);
    if (res == NULL) {
        printf("Failed to retrieve error count\n");
        goto out;
    }
    pclose(fp);
    printf("Device correctable errors cleared!\n");
    printf("Device correctable errors detected: %s\n", correctable);
    err = 0;
out:
    if (fd > 0)
        close(fd);
    return err;
}

static struct logpage {
    const char *field;
    char       datastr[128];
} d0_log_page[] = {
    { "NAND Writes (Bytes Written)", { 0 }},
    { "Program Failure Count", { 0 }},
    { "Erase Failures", { 0 }},
    { "Bad Block Count", { 0 }},
    { "NAND XOR/RAID Recovery Trigger Events", { 0 }},
    { "NSZE Change Supported", { 0 }},
    { "Number of NSZE Modifications", { 0 }}
};

static void init_d0_log_page(__u8 *buf, __u8 nsze)
{
    unsigned int logD0[D0_log_size/sizeof(int)] = { 0 };
    __u64 count_lo, count_hi, count;

    memcpy(logD0, buf, sizeof(logD0));


    count = ((__u64)logD0[45] << 32) | logD0[44];
    sprintf(d0_log_page[0].datastr, "0x%"PRIx64, le64_to_cpu(count));

    count_hi = ((__u64)logD0[39] << 32) | logD0[38];
    count_lo = ((__u64)logD0[37] << 32) | logD0[36];
    if (count_hi != 0)
        sprintf(d0_log_page[1].datastr, "0x%"PRIx64"%016"PRIx64,
                le64_to_cpu(count_hi), le64_to_cpu(count_lo));
    else
        sprintf(d0_log_page[1].datastr, "0x%"PRIx64, le64_to_cpu(count_lo));

    count = ((__u64)logD0[25] << 32) | logD0[24];
    sprintf(d0_log_page[2].datastr, "0x%"PRIx64, le64_to_cpu(count));

    sprintf(d0_log_page[3].datastr, "0x%x", logD0[3]);

    count_lo = ((__u64)logD0[37] << 32) | logD0[36];
    count = ((__u64)logD0[25] << 32) | logD0[24];
    count = (__u64)logD0[3] - (count_lo + count);
    sprintf(d0_log_page[4].datastr, "0x%"PRIx64, le64_to_cpu(count));

    sprintf(d0_log_page[5].datastr, "0x%x", nsze);
    sprintf(d0_log_page[6].datastr, "0x%x", logD0[1]);
}

/* OCP and Vendor specific log data format */
struct micron_vs_logpage {
    char *field;
    int  size;  /* FB client spec version 1.0 sizes - M5410 models */
    int  size2; /* FB client spec version 0.7 sizes - M5407 models */
}
/* Smart Health Log information as per OCP spec M51CX models */
ocp_c0_log_page[] = {
    { "Physical Media Units Written", 16},
    { "Physical Media Units Read", 16 },
    { "Raw Bad User NAND Block Count", 6},
    { "Normalized Bad User NAND Block Count", 2},
    { "Raw Bad System NAND Block Count", 6},
    { "Normalized Bad System NAND Block Count", 2},
    { "XOR Recovery Count", 8},
    { "Uncorrectable Read Error Count", 8},
    { "Soft ECC Error Count", 8},
    { "SSD End to End Detected Counts", 4},
    { "SSD End to End Corrected Errors", 4},
    { "System data % life-used", 1},
    { "Refresh Count", 7},
    { "Maximum User Data Erase Count", 4},
    { "Minimum User Data Erase Count", 4},
    { "Thermal Throttling Count", 1},
    { "Thermal Throttling Status", 1},
    { "Reserved", 6},
    { "PCIe Correctable Error count", 8},
    { "Incomplete Shutdowns", 4},
    { "Reserved", 4},
    { "% Free Blocks", 1},
    { "Reserved", 7},
    { "Capacitor Health", 2},
    { "Reserved", 6},
    { "Unaligned I/O", 8},
    { "Security Version Number", 8},
    { "NUSE", 8},
    { "PLP Start Count", 16},
    { "Endurance Estimate", 16},
    { "Reserved", 302},
    { "Log Page Version", 2},
    { "Log Page GUID", 16},
},
/* Vendor Specific Health Log information */
fb_log_page[] = {
    { "Physical Media Units Written - TLC",  16, 16 },
    { "Physical Media Units Written - SLC",  16, 16 },
    { "Normalized Bad User NAND Block Count", 2, 2},
    { "Raw Bad User NAND Block Count", 6, 6},
    { "XOR Recovery Count", 8, 8},
    { "Uncorrectable Read Error Count", 8, 8},
    { "SSD End to End Corrected Errors", 8, 8},
    { "SSD End to End Detected Counts", 4, 8},
    { "SSD End to End Uncorrected Counts", 4, 8},
    { "System data % life-used", 1, 1},
    { "Reserved", 0, 3},
    { "Minimum User Data Erase Count - TLC", 8, 8},
    { "Maximum User Data Erase Count - TLC", 8, 8},
    { "Average User Data Erase Count - TLC", 0, 8},
    { "Minimum User Data Erase Count - SLC", 8, 8},
    { "Maximum User Data Erase Count - SLC", 8, 8},
    { "Average User Data Erase Count - SLC", 0, 8},
    { "Normalized Program Fail Count", 2, 2},
    { "Raw Program Fail Count", 6, 6},
    { "Normalized Erase Fail Count", 2, 2},
    { "Raw Erase Fail Count", 6, 6},
    { "Pcie Correctable Error Count", 8, 8},
    { "% Free Blocks (User)", 1, 1},
    { "Reserved", 0, 3},
    { "Security Version Number", 8, 8},
    { "% Free Blocks (System)", 1, 1},
    { "Reserved", 0, 3},
    { "Dataset Management (Deallocate) Commands", 16, 16},
    { "Incomplete TRIM Data", 8, 8},
    { "% Age of Completed TRIM", 1, 2},
    { "Background Back-Pressure Gauge", 1, 1},
    { "Reserved", 0, 3},
    { "Soft ECC Error Count", 8, 8},
    { "Refresh Count", 8, 8},
    { "Normalized Bad System NAND Block Count", 2, 2},
    { "Raw Bad System NAND Block Count", 6, 6},
    { "Endurance Estimate", 16, 16},
    { "Thermal Throttling Count", 1, 1},
    { "Thermal Throttling Status", 1, 1},
    { "Unaligned I/O", 8, 8},
    { "Physical Media Units Read", 16, 16},
    { "Reserved", 279, 0},
    { "Log Page Version", 2, 0},
    { "READ CMDs exceeding threshold", 0, 4},
    { "WRITE CMDs exceeding threshold", 0, 4},
    { "TRIMs CMDs exceeding threshold", 0, 4},
    { "Reserved", 0, 4},
    { "Reserved", 0, 210},
    { "Log Page Version", 0, 2},
    { "Log Page GUID", 0, 16},
};

/* Common function to print Micron VS log pages */
static void print_micron_vs_logs(
    __u8                     *buf,             /* raw log data */
    struct micron_vs_logpage *log_page,        /* format of the data */
    int                      field_count,      /* log field count */
    struct json_object       *stats,           /* json object to add fields */
    __u8                     spec              /* ocp spec index */
)
{
    __u64 lval_lo, lval_hi;
    __u32 ival;
    __u16 sval;
    __u8  cval, lval[8] = { 0 };
    int field;
    int offset = 0;

    for (field = 0; field < field_count; field++) {
        char datastr[1024] = { 0 };
        char *sfield = NULL;
        int size = (spec == 0) ? log_page[field].size : log_page[field].size2;
        if (size == 0) continue;
        sfield = log_page[field].field;
        if (size == 16) {
            if (strstr(sfield, "GUID")) {
                sprintf(datastr, "0x%"PRIx64"%"PRIx64"",
                        (uint64_t)le64_to_cpu(*(uint64_t *)(&buf[offset + 8])),
                        (uint64_t)le64_to_cpu(*(uint64_t *)(&buf[offset])));
            } else {
                lval_lo = *((__u64 *)(&buf[offset]));
                lval_hi = *((__u64 *)(&buf[offset + 8]));
                if (lval_hi)
                    sprintf(datastr, "0x%"PRIx64"%016"PRIx64"",
                            le64_to_cpu(lval_hi), le64_to_cpu(lval_lo));
                else
                    sprintf(datastr, "0x%"PRIx64"", le64_to_cpu(lval_lo));
            }
        } else if (size == 8) {
            lval_lo = *((__u64 *)(&buf[offset]));
            sprintf(datastr, "0x%"PRIx64"", le64_to_cpu(lval_lo));
        } else if (size == 7) {
            /* 7 bytes will be in little-endian format, with last byte as MSB */
            memcpy(&lval[0], &buf[offset], 7);
            memcpy((void *)&lval_lo, lval, 8);
            sprintf(datastr, "0x%"PRIx64"", le64_to_cpu(lval_lo));
        } else if (size == 6) {
            ival    = *((__u32 *)(&buf[offset]));
            sval    = *((__u16 *)(&buf[offset + 4]));
            lval_lo = (((__u64)sval << 32) | ival);
            sprintf(datastr, "0x%"PRIx64"", le64_to_cpu(lval_lo));
        } else if (size == 4) {
            ival    = *((__u32 *)(&buf[offset]));
            sprintf(datastr, "0x%x", le32_to_cpu(ival));
        } else if (size == 2) {
            sval = *((__u16 *)(&buf[offset]));
            sprintf(datastr, "0x%04x", le16_to_cpu(sval));
        } else if (size == 1) {
            cval = buf[offset];
            sprintf(datastr, "0x%02x", cval);
        } else {
            sprintf(datastr, "0");
        }
        offset += size;
        /* do not print reserved values */
        if (strstr(sfield, "Reserved"))
            continue;
        if (stats != NULL) {
            json_object_add_value_string(stats, sfield, datastr);
        } else {
            printf("%-40s : %-4s\n", sfield, datastr);
        }
    }
}

static void print_smart_cloud_health_log(__u8 *buf, bool is_json)
{
    struct json_object *root;
    struct json_object *logPages;
    struct json_object *stats = NULL;
    int    field_count = sizeof(ocp_c0_log_page)/sizeof(ocp_c0_log_page[0]);

    if (is_json) {
        root = json_create_object();
        stats = json_create_object();
        logPages = json_create_array();
        json_object_add_value_array(root, "OCP SMART Cloud Health Log: 0xC0",
                                    logPages);
    }

    print_micron_vs_logs(buf, ocp_c0_log_page, field_count, stats, 0);

    if (is_json) {
        json_array_add_value_object(logPages, stats);
        json_print_object(root, NULL);
        printf("\n");
        json_free_object(root);
    }
}

static void print_nand_stats_fb(__u8 *buf, __u8 *buf2, __u8 nsze, bool is_json, __u8 spec)
{
    struct json_object *root;
    struct json_object *logPages;
    struct json_object *stats = NULL;
    int    field_count = sizeof(fb_log_page)/sizeof(fb_log_page[0]);

    if (is_json) {
        root = json_create_object();
        stats = json_create_object();
        logPages = json_create_array();
        json_object_add_value_array(root, "Extended Smart Log Page : 0xFB",
                                    logPages);
    }

    print_micron_vs_logs(buf, fb_log_page, field_count, stats, spec);

    /* print last three entries from D0 log page */
    if (buf2 != NULL) {
        init_d0_log_page(buf2, nsze);

        if (is_json) {
            for (int i = 0; i < 7; i++) {
                json_object_add_value_string(stats,
                                             d0_log_page[i].field,
                                             d0_log_page[i].datastr);
            }
        } else {
            for (int i = 0; i < 7; i++) {
                printf("%-40s : %s\n", d0_log_page[i].field, d0_log_page[i].datastr);
            }
        }
    }

    if (is_json) {
        json_array_add_value_object(logPages, stats);
        json_print_object(root, NULL);
        printf("\n");
        json_free_object(root);
    }
}

static void print_nand_stats_d0(__u8 *buf, __u8 oacs, bool is_json)
{
    init_d0_log_page(buf, oacs);

    if (is_json) {
        struct json_object *root = json_create_object();
        struct json_object *stats = json_create_object();
        struct json_object *logPages = json_create_array();

        json_object_add_value_array(root,
                                    "Extended Smart Log Page : 0xD0",
                                    logPages);

        for (int i = 0; i < 7; i++) {
            json_object_add_value_string(stats,
                                         d0_log_page[i].field,
                                         d0_log_page[i].datastr);
        }

        json_array_add_value_object(logPages, stats);
        json_print_object(root, NULL);
        printf("\n");
        json_free_object(root);
    } else {
        for (int i = 0; i < 7; i++) {
            printf("%-40s : %s\n", d0_log_page[i].field, d0_log_page[i].datastr);
        }
    }
}

static bool nsze_from_oacs = false; /* read nsze for now from idd[4059]  */

static int micron_nand_stats(int argc, char **argv,
                             struct command *cmd, struct plugin *plugin)
{
    const char *desc = "Retrieve Micron NAND stats for the given device ";
    unsigned int extSmartLog[D0_log_size/sizeof(int)] = { 0 };
    unsigned int logFB[FB_log_size/sizeof(int)] = { 0 };
    eDriveModel eModel = UNKNOWN_MODEL;
    struct nvme_id_ctrl ctrl;
    int fd, err, ctrlIdx;
    __u8 nsze;
    bool has_d0_log = true;
    bool has_fb_log = false;
    bool is_json = true;
    struct format {
        char *fmt;
    };
    const char *fmt = "output format json|normal";
    struct format cfg = {
        .fmt = "json",
    };

    OPT_ARGS(opts) = {
        OPT_FMT("format", 'f', &cfg.fmt, fmt),
        OPT_END()
    };

    fd = parse_and_open(argc, argv, desc, opts);
    if (fd < 0) {
        printf("\nDevice not found \n");;
        return -1;
    }

    if (strcmp(cfg.fmt, "normal") == 0)
        is_json = false;

    err = nvme_identify_ctrl(fd, &ctrl);
    if (err) {
        printf("Error %d retrieving controller identification data\n", err);
        goto out;
    }

    /* pull log details based on the model name */
    sscanf(argv[optind], "/dev/nvme%d", &ctrlIdx);
    if ((eModel = GetDriveModel(ctrlIdx)) == UNKNOWN_MODEL) {
        printf ("Unsupported drive model for vs-nand-stats command\n");
        err = -1;
        goto out;
    }

    err = nvme_get_log(fd, NVME_NSID_ALL, 0xD0, false, NVME_NO_LOG_LSP,
                       D0_log_size, extSmartLog);
    has_d0_log = (0 == err);

    /* should check for firmware version if this log is supported or not */
    if (eModel != M5407 && eModel != M5410) {
        err = nvme_get_log(fd, NVME_NSID_ALL, 0xFB, false, NVME_NO_LOG_LSP,
                           FB_log_size, logFB);
        has_fb_log = (0 == err);
    }

    nsze = (ctrl.vs[987] == 0x12);

    if (nsze == 0 && nsze_from_oacs)
        nsze = ((ctrl.oacs >> 3) & 0x1);

    if (has_fb_log) {
        __u8 spec = (eModel == M5410) ? 0 : 1;  /* FB spec version */
        print_nand_stats_fb((__u8 *)logFB, (__u8 *)extSmartLog, nsze, is_json, spec);
    } else if (has_d0_log) {
        print_nand_stats_d0((__u8 *)extSmartLog, nsze, is_json);
        err = 0;
    }
out:
    close(fd);
    if (err > 0)
        nvme_show_status(err);
    return nvme_status_to_errno(err, false);
}


static void GetDriveInfo(const char *strOSDirName, int nFD,
                         struct nvme_id_ctrl *ctrlp)
{
    FILE *fpOutFile = NULL;
    char tempFile[256] = { 0 };
    char strBuffer[1024] = { 0 };
    char model[41] = { 0 };
    char serial[21] = { 0 };
    char fwrev[9] = { 0 };
    char *strPDir = strdup(strOSDirName);
    char *strDest = dirname(strPDir);

    sprintf(tempFile, "%s/%s", strDest, "drive-info.txt");
    fpOutFile = fopen(tempFile, "w+");
    if (!fpOutFile) {
        printf("Failed to create %s\n", tempFile);
        free(strPDir);
        return;
    }

    strncpy(model, ctrlp->mn, 40);
    strncpy(serial, ctrlp->sn, 20);
    strncpy(fwrev, ctrlp->fr, 8);

    sprintf(strBuffer,
            "********************\nDrive Info\n********************\n");

    fprintf(fpOutFile, "%s", strBuffer);
    sprintf(strBuffer,
            "%-20s : /dev/nvme%d\n%-20s : %s\n%-20s : %-20s\n%-20s : %-20s\n",
            "Device Name", nFD,
            "Model No", (char *)model,
            "Serial No", (char *)serial, "FW-Rev", (char *)fwrev);

    fprintf(fpOutFile, "%s", strBuffer);

    sprintf(strBuffer,
            "\n********************\nPCI Info\n********************\n");

    fprintf(fpOutFile, "%s", strBuffer);

    sprintf(strBuffer,
            "%-22s : %04X\n%-22s : %04X\n",
            "VendorId", vendor_id, "DeviceId", device_id);
    fprintf(fpOutFile, "%s", strBuffer);
    fclose(fpOutFile);
    free(strPDir);
}

static void GetTimestampInfo(const char *strOSDirName)
{
    __u8 outstr[1024];
    time_t t;
    struct tm *tmp;
    size_t num;
    char *strPDir;
    char *strDest;

    t = time(NULL);
    tmp = localtime(&t);
    if (tmp == NULL)
        return;

    num = strftime((char *)outstr, sizeof(outstr),
                   "Timestamp (UTC): %a, %d %b %Y %T %z", tmp);
    num += sprintf((char *)(outstr + num), "\nPackage Version: 1.4");
    if (num) {
        strPDir = strdup(strOSDirName);
        strDest = dirname(strPDir);
        WriteData(outstr, num, strDest, "timestamp_info.txt", "timestamp");
        free(strPDir);
    }
}

static void GetCtrlIDDInfo(const char *dir, struct nvme_id_ctrl *ctrlp)
{
    WriteData((__u8*)ctrlp, sizeof(*ctrlp), dir,
              "nvme_controller_identify_data.bin", "id-ctrl");
}

static void GetSmartlogData(int fd, const char *dir)
{
    struct nvme_smart_log smart_log;
    if (nvme_smart_log(fd, -1, &smart_log) == 0) {
        WriteData((__u8*)&smart_log, sizeof(smart_log), dir,
                  "smart_data.bin", "smart log");
    }
}

static void GetErrorlogData(int fd, int entries, const char *dir)
{
    int logSize = entries * sizeof(struct nvme_error_log_page);
    struct nvme_error_log_page *error_log =
                (struct nvme_error_log_page *)calloc(1, logSize);

    if (error_log == NULL)
        return;

    if (nvme_error_log(fd, entries, error_log) == 0) {
        WriteData((__u8*)error_log, logSize, dir,
                  "error_information_log.bin", "error log");
    }

    free(error_log);
}

static void GetGenericLogs(int fd, const char *dir)
{
    struct nvme_self_test_log self_test_log;
    struct nvme_firmware_log_page fw_log;
    struct nvme_effects_log_page effects;
    struct nvme_persistent_event_log_head pevent_log_head;
    void *pevent_log_info = NULL;
    __u32 log_len = 0;
    int err = 0 ;
    bool huge = false;

    /* get self test log */
    if (nvme_self_test_log(fd, sizeof(self_test_log), &self_test_log) == 0) {
        WriteData((__u8*)&self_test_log, sizeof(self_test_log), dir,
                  "drive_self_test.bin", "self test log");
    }

    /* get fw slot info log */
    if (nvme_fw_log(fd, &fw_log) == 0) {
        WriteData((__u8*)&fw_log, sizeof(fw_log), dir,
                  "firmware_slot_info_log.bin", "firmware log");
    }

    /* get effects log */
    if (nvme_effects_log(fd, &effects) == 0) {
        WriteData((__u8*)&effects, sizeof(effects), dir,
                  "command_effects_log.bin", "effects log");
    }
    
    /* get persistent event log */
    (void)nvme_persistent_event_log(fd, NVME_PEVENT_LOG_RELEASE_CTX,
                                    sizeof(pevent_log_head), &pevent_log_head);
    memset(&pevent_log_head, 0, sizeof(pevent_log_head));
    err = nvme_persistent_event_log(fd, NVME_PEVENT_LOG_EST_CTX_AND_READ, 
                        sizeof(pevent_log_head), &pevent_log_head);
    if (err) {
        fprintf(stderr, "Setting persistent event log read ctx failed (ignored)!\n");
        return;
    }

    log_len = le64_to_cpu(pevent_log_head.tll);
    pevent_log_info = nvme_alloc(log_len, &huge);
    if (!pevent_log_info) {
        perror("could not alloc buffer for persistent event log page (ignored)!\n");
        return;
    }
    err = nvme_persistent_event_log(fd, NVME_PEVENT_LOG_READ,
                                    log_len, pevent_log_info);
    if (err == 0) {
        WriteData((__u8*)pevent_log_info, log_len, dir,
                  "persistent_event_log.bin", "persistent event log");
    }
    nvme_free(pevent_log_info, huge);
    return;
}

static void GetNSIDDInfo(int fd, const char *dir, int nsid)
{
    char file[PATH_MAX] = { 0 };
    struct nvme_id_ns ns;

    if (nvme_identify_ns(fd, nsid, 0, &ns) == 0) {
        sprintf(file, "identify_namespace_%d_data.bin", nsid);
        WriteData((__u8*)&ns, sizeof(ns), dir, file, "id-ns");
    }
}

static void GetOSConfig(const char *strOSDirName)
{
    FILE *fpOSConfig = NULL;
    char strBuffer[1024], strTemp[1024];
    char strFileName[PATH_MAX];
    int i;

    struct {
        char *strcmdHeader;
        char *strCommand;
    } cmdArray[] = {
        { (char *)"SYSTEM INFORMATION", (char *)"uname -a >> %s" },
        { (char *)"LINUX KERNEL MODULE INFORMATION", (char *)"lsmod >> %s" },
        { (char *)"LINUX SYSTEM MEMORY INFORMATION", (char *)"cat /proc/meminfo >> %s" },
        { (char *)"SYSTEM INTERRUPT INFORMATION", (char *)"cat /proc/interrupts >> %s" },
        { (char *)"CPU INFORMATION", (char *)"cat /proc/cpuinfo >> %s" },
        { (char *)"IO MEMORY MAP INFORMATION", (char *)"cat /proc/iomem >> %s" },
        { (char *)"MAJOR NUMBER AND DEVICE GROUP", (char *)"cat /proc/devices >> %s" },
        { (char *)"KERNEL DMESG", (char *)"dmesg >> %s" },
        { (char *)"/VAR/LOG/MESSAGES", (char *)"cat /var/log/messages >> %s" }
    };

    sprintf(strFileName, "%s/%s", strOSDirName, "os_config.txt");

    for (i = 0; i < 7; i++) {
        fpOSConfig = fopen(strFileName, "a+");
        fprintf(fpOSConfig,
                "\n\n\n\n%s\n-----------------------------------------------\n",
                cmdArray[i].strcmdHeader);
        if (NULL != fpOSConfig) {
            fclose(fpOSConfig);
            fpOSConfig = NULL;
        }
        strcpy(strTemp, cmdArray[i].strCommand);
        sprintf(strBuffer, strTemp, strFileName);
        if (system(strBuffer))
            fprintf(stderr, "Failed to send \"%s\"\n", strBuffer);
    }
}

static int micron_telemetry_log(int fd, __u8 gen, __u8 type, __u8 **data,
                                int *logSize, int da)
{
    int err, bs = 512, offset = bs;
    unsigned short data_area[4];
    unsigned char  ctrl_init = (type == 0x8);

    __u8 *buffer = (unsigned char *)calloc(bs, 1);
    if (buffer == NULL)
        return -1;
    err = nvme_get_telemetry_log(fd, buffer, gen, ctrl_init, bs, 0);
    if (err != 0) {
        fprintf(stderr, "Failed to get telemetry log header for 0x%X\n", type);
        if (buffer != NULL) {
            free(buffer);
        }
        return err;
    }

    /* compute size of the log */
    data_area[1] = buffer[9]  << 8 | buffer[8];
    data_area[2] = buffer[11] << 8 | buffer[10];
    data_area[3] = buffer[13] << 8 | buffer[12];
    data_area[0] = data_area[1] > data_area[2] ? data_area[1] : data_area[2];
    data_area[0] = data_area[3] > data_area[0] ? data_area[3] : data_area[0];

    if (data_area[da] == 0) {
        fprintf(stderr, "Requested telemetry data for 0x%X is empty\n", type);
        if (buffer != NULL) {
            free(buffer);
            buffer = NULL;
        }
        return -1;
    }

    *logSize = data_area[da] * bs;
    offset = bs;
    err = 0;
    if ((buffer = (unsigned char *)realloc(buffer, (size_t)(*logSize))) != NULL) {
        while (err == 0 && offset != *logSize) {
           err = nvme_get_telemetry_log(fd, buffer + offset, gen, ctrl_init, bs, offset);
           offset += bs;
        }
    }

    if (err == 0 && buffer != NULL) {
        *data = buffer;
    } else {
        fprintf(stderr, "Failed to get telemetry data for 0x%x\n", type);
        if (buffer != NULL)
            free(buffer);
    }

    return err;
}

static int GetTelemetryData(int fd, const char *dir)
{
    unsigned char *buffer = NULL;
    int i, err, logSize = 0;
    char msg[256] = {0};
    struct {
        __u8 log;
        char *file;
    } tmap[] = {
        {0x07, "nvmetelemetrylog.bin"},
        {0x08, "nvmetelemetrylog.bin"},
    };

    for(i = 0; i < (int)(sizeof(tmap)/sizeof(tmap[0])); i++) {
        err = micron_telemetry_log(fd, (tmap[i].log == 0x07),
                                   tmap[i].log, &buffer, &logSize, 0);
        if (err == 0 && logSize > 0 && buffer != NULL) {
            sprintf(msg, "telemetry log: 0x%X", tmap[i].log);
            WriteData(buffer, logSize, dir, tmap[i].file, msg);
            if (buffer != NULL)
                free(buffer);
        }
        buffer = NULL;
        logSize = 0;
    }
    return err;
}

static int GetFeatureSettings(int fd, const char *dir)
{
    unsigned char *bufp, buf[4096] = { 0 };
    int i, err, len, errcnt = 0;
    __u32 attrVal = 0;
    char msg[256] = { 0 };

    struct features {
        int id;
        char *file;
    } fmap[] = {
        {0x01, "nvme_feature_setting_arbitration.bin"},
        {0x02, "nvme_feature_setting_pm.bin"},
        {0x03, "nvme_feature_setting_lba_range_namespace_1.bin"},
        {0x04, "nvme_feature_setting_temp_threshold.bin"},
        {0x05, "nvme_feature_setting_error_recovery.bin"},
        {0x06, "nvme_feature_setting_volatile_write_cache.bin"},
        {0x07, "nvme_feature_setting_num_queues.bin"},
        {0x08, "nvme_feature_setting_interrupt_coalescing.bin"},
        {0x09, "nvme_feature_setting_interrupt_vec_config.bin"},
        {0x0A, "nvme_feature_setting_write_atomicity.bin"},
        {0x0B, "nvme_feature_setting_async_event_config.bin"},
        {0x80, "nvme_feature_setting_sw_progress_marker.bin"},
    };

    for (i = 0; i < (int)(sizeof(fmap)/sizeof(fmap[0])); i++) {
        if (fmap[i].id == 0x03) {
            len = 4096;
            bufp = (unsigned char *)(&buf[0]);
        } else  {
            len = 0;
            bufp = NULL;
        }

        err = nvme_get_feature(fd, 1, fmap[i].id, 0, 0x0, 0, len, bufp, &attrVal);
        if (err == 0) {
            sprintf(msg, "feature: 0x%X", fmap[i].id);
            WriteData((__u8*)&attrVal, sizeof(attrVal), dir, fmap[i].file, msg);
            if (bufp != NULL) {
                WriteData(bufp, len, dir, fmap[i].file, msg);
            }
        } else {
            fprintf(stderr, "Feature 0x%x data not retrieved, error %d (ignored)!\n",
                    fmap[i].id, err);
            errcnt++;
        }
    }
    return (int)(errcnt == sizeof(fmap)/sizeof(fmap[0]));
}

static int micron_drive_info(int argc, char **argv, struct command *cmd,
                                struct plugin *plugin)
{
    const char *desc = "Get drive HW information";
    int fd, err = 0;
    struct nvme_id_ctrl ctrl =  { 0 };
    struct nvme_admin_cmd admin_cmd = { 0 };
    struct fb_drive_info {
        unsigned char hw_ver_major;
        unsigned char hw_ver_minor;
        unsigned char ftl_unit_size;
        unsigned char bs_ver_major;
        unsigned char bs_ver_minor;
    } dinfo = { 0 };
    eDriveModel model = UNKNOWN_MODEL;
    bool is_json = false;
    struct json_object *root, *driveInfo;
    struct format {
        char *fmt;
    };

    const char *fmt = "output format normal";
    struct format cfg = {
        .fmt = "normal",
    };

    OPT_ARGS(opts) = {
        OPT_FMT("format", 'f', &cfg.fmt, fmt),
        OPT_END()
    };

    if ((fd = micron_parse_options(argc, argv, desc, opts, &model)) < 0)
        return err;

    if (model == UNKNOWN_MODEL) {
        fprintf(stderr, "ERROR : Unsupported drive for vs-drive-info cmd");
        return -1;
    }

    if (strcmp(cfg.fmt, "json") == 0)
        is_json = true;

    if (model == M5407) {
        admin_cmd.opcode = 0xDA,
        admin_cmd.addr = (__u64) (uintptr_t) &dinfo;
        admin_cmd.data_len = (__u32)sizeof(dinfo);
        admin_cmd.cdw12 = 3;
        err = ioctl(fd, NVME_IOCTL_ADMIN_CMD, &admin_cmd);
        if (err) {
            fprintf(stderr, "ERROR : drive-info opcode failed with 0x%x\n", err);
            return -1;
        }
    } else {
        err = nvme_identify_ctrl(fd, &ctrl);
        if (err) {
            fprintf(stderr, "ERROR : identify_ctrl() failed with 0x%x\n", err);
            return -1;
        }
        dinfo.hw_ver_major = ctrl.vs[820];
        dinfo.hw_ver_minor = ctrl.vs[821];
    }

    if (is_json) {
        struct json_object *pinfo = json_create_object();
        char tempstr[64] = { 0 };
        root = json_create_object();
        driveInfo = json_create_array();
        json_object_add_value_array(root, "Micron Drive HW Information", driveInfo);
        sprintf(tempstr, "%hhu.%hhu", dinfo.hw_ver_major, dinfo.hw_ver_minor);
        json_object_add_value_string(pinfo, "Drive Hardware Version", tempstr);

        if (dinfo.ftl_unit_size) {
            sprintf(tempstr, "%hhu KB", dinfo.ftl_unit_size);
            json_object_add_value_string(pinfo, "FTL_unit_size", tempstr);
        }

        if (dinfo.bs_ver_major != 0 || dinfo.bs_ver_minor != 0) {
            sprintf(tempstr, "%hhu.%hhu", dinfo.bs_ver_major, dinfo.bs_ver_minor);
            json_object_add_value_string(pinfo, "Boot Spec.Version", tempstr);
        }

        json_array_add_value_object(driveInfo, pinfo);
        json_print_object(root, NULL);
        printf("\n");
        json_free_object(root);
    } else {
        printf("Drive Hardware Version: %hhu.%hhu\n",
                dinfo.hw_ver_major, dinfo.hw_ver_minor);

        if (dinfo.ftl_unit_size)
            printf("FTL_unit_size: %hhu KB\n", dinfo.ftl_unit_size);

        if (dinfo.bs_ver_major != 0 || dinfo.bs_ver_minor != 0) {
            printf("Boot  Spec.Version: %hhu.%hhu\n",
                    dinfo.bs_ver_major, dinfo.bs_ver_minor);
        }
    }

    return 0;
}

static int micron_cloud_ssd_plugin_version(int argc, char **argv,
                                struct command *cmd, struct plugin *plugin)
{
    printf("nvme-cli Micron cloud SSD plugin version: %s.%s\n",
           __version_major, __version_minor);
    return 0;
}

static int micron_plugin_version(int argc, char **argv, struct command *cmd,
                                struct plugin *plugin)
{
    printf("nvme-cli Micron plugin version: %s.%s.%s\n",
           __version_major, __version_minor, __version_patch);
    return 0;
}

static int micron_logpage_dir(int argc, char **argv, struct command *cmd,
                                struct plugin *plugin)
{
    printf("This command is not implemented for the drive\n");
    return 0;
}
/* Binary format of firmware activation history entry */
struct __attribute__((__packed__)) fw_activation_history_entry {
    __u8                               version;
    __u8                               length;
    __u16                              rsvd1;
    __le16                             valid;
    __le64                             power_on_hour;
    __le64                             rsvd2;
    __le64                             power_cycle_count;
    __u8                               previous_fw[8];
    __u8                               activated_fw[8];
    __u8                               slot;
    __u8                               commit_action_type;
    __le16                             result;
    __u8                               rsvd3[14];
};


/* Binary format for firmware activation history table */
struct __attribute__((__packed__)) micron_fw_activation_history_table {
    __u8                               log_page;
    __u8                               rsvd1[3];
    __le32                             num_entries;
    struct fw_activation_history_entry entries[20];
    __u8                               rsvd2[2790];
    __u16                              version;
    __u8                               GUID[16];
};

/* header to be printed  field widths = 10 | 12 | 10 | 11 | 12 | 9 | 9 | 9 */

const char *fw_activation_history_table_header = "\
__________________________________________________________________________________\n\
          |           |         |          |           |        |        |        \n\
Firmware  |  Power    | Power   | Previous | New FW    | Slot   | Commit | Result \n\
Activation|  On Hour  | cycle   | firmware | activated | number | Action |        \n\
Counter   |           | count   |          |           |        | Type   |        \n\
__________|___________|_________|__________|___________|________|________|________\n";

static int display_fw_activate_entry (
    int                                entry_count,
    struct fw_activation_history_entry *entry,
    char                               *formatted_entry,
    struct json_object                 *stats
)
{
    time_t    timestamp, hours;
    char      buffer[32];
    __u8      minutes, seconds;
    char      *ca[] = {"000b", "001b", "010b", "011b"};
    char      *ptr = formatted_entry;
    int       index = 0, entry_size = 82;

    if (entry->version != 1 || entry->length != 64) {
        fprintf(stderr, "unsupported entry ! version: %x with length: %d\n",
                entry->version, entry->length);
        return -EINVAL;
    }

    sprintf(ptr, "%d", entry_count);
    ptr += 10;

    timestamp = (le64_to_cpu(entry->power_on_hour) & 0x0000FFFFFFFFFFFFUL) / 1000;
    hours = timestamp / 3600;
    minutes = (timestamp % 3600) / 60;
    seconds = (timestamp % 3600) % 60;
    sprintf(ptr, "|%"PRIu64":%hhu:%hhu", (uint64_t)hours, minutes, seconds);
    ptr += 12;

    sprintf(ptr, "| %"PRIu64, le64_to_cpu(entry->power_cycle_count));
    ptr += 10;

    /* firmware details */
    memset(buffer, 0, sizeof(buffer));
    memcpy(buffer, entry->previous_fw, sizeof(entry->previous_fw));
    sprintf(ptr, "| %s", buffer);
    ptr += 11;

    memset(buffer, 0, sizeof(buffer));
    memcpy(buffer, entry->activated_fw, sizeof(entry->activated_fw));
    sprintf(ptr, "| %s", buffer);
    ptr += 12;

    /* firmware slot and commit action*/
    sprintf(ptr, "| %d", entry->slot);
    ptr += 9;

    if (entry->commit_action_type <= 3)
        sprintf(ptr, "| %s", ca[entry->commit_action_type]);
    else
        sprintf(ptr, "| xxxb");
    ptr += 9;

    /* result */
    if (entry->result) {
        sprintf(ptr, "| Fail #%d", entry->result);
    } else {
        sprintf(ptr, "| pass");
    }

    /* replace all null charecters with spaces */
    ptr = formatted_entry;
    while (index < entry_size) {
        if (ptr[index] == '\0')
            ptr[index] = ' ';
        index++;
    }
    return 0;
}


static int micron_fw_activation_history(int argc, char **argv, struct command *cmd,
                                struct plugin *plugin)
{
    const char *desc = "Retrieve Firmware Activation history of the given drive";
    char formatted_output[100];
    int count = 0;
    unsigned int logC2[C2_log_size/sizeof(int)] = { 0 };
    eDriveModel eModel = UNKNOWN_MODEL;
    int fd, err;
    struct format {
        char *fmt;
    };

    const char *fmt = "output format normal";
    struct format cfg = {
        .fmt = "normal",
    };

    OPT_ARGS(opts) = {
        OPT_FMT("format", 'f', &cfg.fmt, fmt),
        OPT_END()
    };

    if ((fd = micron_parse_options(argc, argv, desc, opts, &eModel)) < 0) {
        return -1;
    }

    if (strcmp(cfg.fmt, "normal") != 0) {
        fprintf (stderr, "only normal format is supported currently\n");
        close(fd);
        return -1;
    }

    /* check if product supports fw_history log */
    err = -EINVAL;
    if (eModel != M51CX) {
        fprintf(stderr, "Unsupported drive model for vs-fw-activate-history command\n");
        goto out;
    }

    err = nvme_get_log(fd, NVME_NSID_ALL, 0xC2, false, NVME_NO_LOG_LSP, C2_log_size, logC2);
    if (err)  {
        fprintf(stderr, "Failed to retrieve fw activation history log, error: %x\n", err);
        goto out;
    }

    /* check if we have atleast one entry to print */
    struct micron_fw_activation_history_table *table =
               (struct micron_fw_activation_history_table *)logC2;

    /* check version and log page */
    if (table->version != 2 || table->log_page != 0xC2) {
        fprintf(stderr, "Unsupported fw activation history page: %x, version: %x\n",
                table->log_page, table->version);
        goto out;
    }

    if (table->num_entries == 0) {
        fprintf(stderr, "No entries were found in fw activation history log\n");
        goto out;
    }

    printf("%s", fw_activation_history_table_header);
    for(count = 0; count < table->num_entries; count++) {
        memset(formatted_output, '\0', 100);
        if (display_fw_activate_entry(count,
                                      &table->entries[count],
                                      formatted_output, NULL) == 0)
        {
            printf("%s\n", formatted_output);
        }
    }
out:
    if (fd > 0)
        close(fd);
    return err;
}

static int micron_error_reason(int argc, char **argv, struct command *cmd,
                                struct plugin *plugin)
{
    printf("This command is not implemented for the drive\n");
    return 0;
}

static int micron_ocp_smart_health_logs(int argc, char **argv, struct command *cmd,
                                struct plugin *plugin)
{
    const char *desc = "Retrieve Smart or Extended Smart Health log for the given device ";
    unsigned int logC0[C0_log_size/sizeof(int)] = { 0 };
    unsigned int logFB[FB_log_size/sizeof(int)] = { 0 };
    struct nvme_id_ctrl ctrl;
    eDriveModel eModel = UNKNOWN_MODEL;
    int fd, err = 0;
    bool is_json = true;
    struct format {
        char *fmt;
    };
    const char *fmt = "output format normal|json";
    struct format cfg = {
        .fmt = "json",
    };

    OPT_ARGS(opts) = {
        OPT_FMT("format", 'f', &cfg.fmt, fmt),
        OPT_END()
    };

    if ((fd = micron_parse_options(argc, argv, desc, opts, &eModel)) < 0) {
        return -1;
    }

    if (strcmp(cfg.fmt, "normal") == 0)
        is_json = false;

    /* For M5410 and M5407, this option prints 0xFB log page */
    if (eModel == M5410 || eModel == M5407) {
        __u8 spec = (eModel == M5410) ? 0 : 1;
        __u8 nsze;

        if ((err = nvme_identify_ctrl(fd, &ctrl)) == 0)
            err = nvme_get_log(fd, NVME_NSID_ALL, 0xFB, false, NVME_NO_LOG_LSP,
                               FB_log_size, logFB);
        if (err) {
            if (err < 0)
                printf("Unable to retrieve smart log 0xFB for the drive\n");
            goto out;
        }

        nsze = (ctrl.vs[987] == 0x12);
        if (nsze == 0 && nsze_from_oacs)
            nsze = ((ctrl.oacs >> 3) & 0x1);
        print_nand_stats_fb((__u8 *)logFB, NULL, nsze, is_json, spec);
        goto out;
    }

    /* check for models that support 0xC0 log */
    if (eModel != M51CX) {
        printf ("Unsupported drive model for vs-smart-add-log commmand\n");
        err = -1;
        goto out;
    }

    err = nvme_get_log(fd, NVME_NSID_ALL, 0xC0, false, NVME_NO_LOG_LSP,
                       C0_log_size, logC0);
    if (err == 0) {
        print_smart_cloud_health_log((__u8 *)logC0, is_json);
    } else if (err < 0) {
        printf("Unable to retrieve extended smart log 0xC0 for the drive\n");
    }
out:
    close(fd);
    if (err > 0)
        nvme_show_status(err);
    return nvme_status_to_errno(err, false);
}

static int micron_clr_fw_activation_history(int argc, char **argv,
                                struct command *cmd, struct plugin *plugin)
{
    const char *desc = "Clear FW activation history";
    int fd, err = 0;
    __u32 result = 0;
    __u8 fid = MICRON_FEATURE_CLEAR_FW_ACTIVATION_HISTORY;
    eDriveModel model = UNKNOWN_MODEL;
    OPT_ARGS(opts) = {
        OPT_END()
    };

    if ((fd = micron_parse_options(argc, argv, desc, opts, &model)) < 0)
        return err;

    if (model != M51CX) {
        printf ("This option is not supported for specified drive\n");
        close(fd);
        return err;
    }

    //err = nvme_set_feature(fd, 1, fid, cdw11, 0, opt.save, 0, 0, &result);
    err = nvme_set_feature(fd, 1, fid, 0, 0, 0, 0, 0, 0, &result);
    if (err == 0) err = (int)result;
    return err;
}

static int micron_telemetry_cntrl_option(int argc, char **argv,
                                struct command *cmd, struct plugin *plugin)
{
    int err = 0;
    __u32 result = 0;
    const char *desc = "Enable or Disable Controller telemetry log generation";
    const char *option = "enable or disable or status";
    const char *select = "select/save values: enable/disable options"
                         "1 - save (persistent), 0 - non-persistent and for "
                         "status options: 0 - current, 1 - default, 2-saved";
    int fd = 0;
    int fid = MICRON_FEATURE_TELEMETRY_CONTROL_OPTION;
    eDriveModel model = UNKNOWN_MODEL;
    struct nvme_id_ctrl ctrl =  { 0 };

    struct {
        char *option;
        int  select;
    } opt = {
        .option = "disable",
        .select= 0,
    };

    OPT_ARGS(opts) = {
        OPT_STRING("option", 'o', "option", &opt.option, option),
        OPT_UINT("select", 's', &opt.select, select),
        OPT_END()
    };

    if ((fd = micron_parse_options(argc, argv, desc, opts, &model)) < 0) {
        return -1;
    }

    err = nvme_identify_ctrl(fd, &ctrl);
    if ((ctrl.lpa & 0x8) != 0x8) {
           printf("drive doesn't support host/controller generated telemetry logs\n");
           close(fd);
           return err;
    }

    if (!strcmp(opt.option, "enable")) {
        err = nvme_set_feature(fd, 1, fid, 1, 0, (opt.select & 0x1), 0, 0, 0, &result);
        if (err == 0) {
            printf("successfully set controller telemetry option\n");
        } else {
            printf("Failed to set controller telemetry option\n");
        }
    } else if (!strcmp(opt.option, "disable")) {
        err = nvme_set_feature(fd, 1, fid, 0, 0, (opt.select & 0x1), 0, 0, 0, &result);
        if (err == 0) {
            printf("successfully disabled controller telemetry option\n");
        } else {
            printf("Failed to disable controller telemetry option\n");
        }
    } else if (!strcmp(opt.option, "status")) {
        opt.select &= 0x3;
        err = nvme_get_feature(fd, 1, fid, opt.select, 0, 0, 0, 0, &result);
        if (err == 0) {
            printf("Controller telemetry option : %s\n",
                    (result) ? "enabled" : "disabled");
        } else {
            printf("Failed to retrieve controller telemetry option\n");
        }
    } else {
        printf("invalid option %s, valid values are enable,disable or status\n", opt.option);
        close(fd);
        return -1;
    }

    close(fd);
    return err;
}

static int micron_internal_logs(int argc, char **argv, struct command *cmd,
                                struct plugin *plugin)
{
    int err = -EINVAL;
    int fd = 0;
    int ctrlIdx, telemetry_option = 0;
    char strOSDirName[1024];
    char strCtrlDirName[1024];
    char strMainDirName[256];
    unsigned int *puiIDDBuf;
    unsigned int uiMask;
    struct nvme_id_ctrl ctrl;
    char sn[20] = { 0 };
    char msg[256] = { 0 };

    struct {
        unsigned char ucLogPage;
        const char *strFileName;
        int nLogSize;
        int nMaxSize;
    } aVendorLogs[32] = {
        { 0x03, "firmware_slot_info_log.bin", 512, 0 },
        { 0xC1, "nvmelog_C1.bin", 0, 0 },
        { 0xC2, "nvmelog_C2.bin", 0, 0 },
        { 0xC4, "nvmelog_C4.bin", 0, 0 },
        { 0xC5, "nvmelog_C5.bin", C5_log_size, 0 },
        { 0xD0, "nvmelog_D0.bin", D0_log_size, 0 },
        { 0xE6, "nvmelog_E6.bin", 0, 0 },
        { 0xE7, "nvmelog_E7.bin", 0, 0 }
    },
    aM51XXLogs[] = {
        { 0xFB, "nvmelog_FB.bin", 4096, 0 },  /* this should be collected first for M51AX */
        { 0xD0, "nvmelog_D0.bin", 512, 0 },
        { 0x03, "firmware_slot_info_log.bin", 512, 0},
        { 0xF7, "nvmelog_F7.bin", 4096, 512 * 1024 },
        { 0xF8, "nvmelog_F8.bin", 4096, 512 * 1024 },
        { 0xF9, "nvmelog_F9.bin", 4096, 200 * 1024 * 1024 },
        { 0xFC, "nvmelog_FC.bin", 4096, 200 * 1024 * 1024 },
        { 0xFD, "nvmelog_FD.bin", 4096, 80 * 1024 * 1024 }
    },
    aM51AXLogs[] = {
        { 0xCA, "nvmelog_CA.bin", 512, 0 },
        { 0xFA, "nvmelog_FA.bin", 4096, 15232 },
        { 0xF6, "nvmelog_F6.bin", 4096, 512 * 1024 },
        { 0xFE, "nvmelog_FE.bin", 4096, 512 * 1024 },
        { 0xFF, "nvmelog_FF.bin", 4096, 162 * 1024 },
        { 0x04, "changed_namespace_log.bin", 4096, 0 },
        { 0x05, "command_effects_log.bin", 4096, 0 },
        { 0x06, "drive_self_test.bin", 4096, 0 }
    },
    aM51BXLogs[] = {
        { 0xFA, "nvmelog_FA.bin", 4096, 16376 },
        { 0xFE, "nvmelog_FE.bin", 4096, 256 * 1024 },
        { 0xFF, "nvmelog_FF.bin", 4096, 64 * 1024 },
        { 0xCA, "nvmelog_CA.bin", 512, 1024 }
    };

    eDriveModel eModel;

    const char *desc = "This retrieves the micron debug log package";
    const char *package = "Log output data file name (required)";
    const char *type = "telemetry log type - host or controller";
    const char *data_area = "telemetry log data area 1, 2 or 3";
    unsigned char *dataBuffer = NULL;
    int bSize = 0;
    int maxSize = 0;

    struct config {
        char *type;
        char *package;
        int  data_area;
        int  log;
    };

    struct config cfg = {
        .type = "",
        .package = "",
        .data_area = -1,
        .log = 0x07,
    };

    OPT_ARGS(opts) = {
        OPT_STRING("type", 't', "log type", &cfg.type, type),
        OPT_STRING("package", 'p', "FILE", &cfg.package, package),
        OPT_UINT("data_area", 'd', &cfg.data_area, data_area),
        OPT_END()
    };

    fd = parse_and_open(argc, argv, desc, opts);

    if (fd < 0)
        goto out;

    /* if telemetry type is specified, check for data area */
    if (strlen(cfg.type) != 0) {
        if (!strcmp(cfg.type, "controller")) {
            cfg.log = 0x08;
        } else if (strcmp(cfg.type, "host")) {
            printf ("telemetry type (host or controller) should be specified i.e. -t=host\n");
            close(fd);
            goto out;
        }

        if (cfg.data_area <= 0 || cfg.data_area > 3) {
            printf ("data area must be selected using -d option ie --d=1,2,3\n");
            close(fd);
            goto out;
        }
        telemetry_option = 1;
    } else if (cfg.data_area > 0) {
        printf ("data area option is valid only for telemetry option (i.e --type=host|controller)\n");
        close(fd);
        goto out;
    }

    if (strlen(cfg.package) == 0) {
        if (telemetry_option)
            printf ("Log data file must be specified. ie -p=logfile.bin\n");
        else
            printf ("Log data file must be specified. ie -p=logfile.zip or -p=logfile.tgz|logfile.tar.gz\n");
        goto out;
    }

    /* pull log details based on the model name */
    sscanf(argv[optind], "/dev/nvme%d", &ctrlIdx);
    if ((eModel = GetDriveModel(ctrlIdx)) == UNKNOWN_MODEL) {
        printf ("Unsupported drive model for vs-internal-log collection\n");
        close(fd);
        goto out;
    }

    err = nvme_identify_ctrl(fd, &ctrl);
    if (err)
        goto out;

    err = -EINVAL;
    if (telemetry_option) {
        if ((ctrl.lpa & 0x8) != 0x8) {
           printf("telemetry option is not supported for specified drive\n");
           close(fd);
           goto out;
        }
        int logSize = 0; __u8 *buffer = NULL; const char *dir = ".";
        err = micron_telemetry_log(fd, 0, cfg.log,  &buffer, &logSize, cfg.data_area);
        if (err == 0 && logSize > 0 && buffer != NULL) {
            sprintf(msg, "telemetry log: 0x%X", cfg.log);
            WriteData(buffer, logSize, dir, cfg.package, msg);
            free(buffer);
        }
        close(fd);
        goto out;
    }

    printf("Preparing log package. This will take a few seconds...\n");

    // trim spaces out of serial number string */
    int i, j = 0;
    for (i = 0; i < sizeof(ctrl.sn); i++) {
        if (isblank(ctrl.sn[i]))
            continue;
        sn[j++] = ctrl.sn[i];
    }
    sn[j] = '\0';
    strcpy(ctrl.sn, sn);

    SetupDebugDataDirectories(ctrl.sn, cfg.package, strMainDirName, strOSDirName, strCtrlDirName);

    GetTimestampInfo(strOSDirName);
    GetCtrlIDDInfo(strCtrlDirName, &ctrl);
    GetOSConfig(strOSDirName);
    GetDriveInfo(strOSDirName, ctrlIdx, &ctrl);

    for (int i = 1; i <= ctrl.nn; i++)
        GetNSIDDInfo(fd, strCtrlDirName, i);

    GetSmartlogData(fd, strCtrlDirName);
    GetErrorlogData(fd, ctrl.elpe, strCtrlDirName);
    GetGenericLogs(fd, strCtrlDirName);

    // pull if telemetry log data is supported
    if ((ctrl.lpa & 0x8) == 0x8)
        GetTelemetryData(fd, strCtrlDirName);

    GetFeatureSettings(fd, strCtrlDirName);

    if (eModel != M5410 && eModel != M5407) {
        memcpy(aVendorLogs, aM51XXLogs, sizeof(aM51XXLogs));
        if (eModel == M51AX)
            memcpy((char *)aVendorLogs + sizeof(aM51XXLogs), aM51AXLogs, sizeof(aM51AXLogs));
        else
            memcpy((char *)aVendorLogs + sizeof(aM51XXLogs), aM51BXLogs, sizeof(aM51BXLogs));
    }

    for (int i = 0; i < (int)(sizeof(aVendorLogs) / sizeof(aVendorLogs[0])) &&
                        aVendorLogs[i].ucLogPage != 0; i++) {
        err = -1;
        switch (aVendorLogs[i].ucLogPage) {
        case 0xC1:
        case 0xC2:
        case 0xC4:
            err = GetLogPageSize(fd, aVendorLogs[i].ucLogPage, &bSize);
            if (err == 0 && bSize > 0)
                err = GetCommonLogPage(fd, aVendorLogs[i].ucLogPage, &dataBuffer, bSize);
            break;

        case 0xE6:
        case 0xE7:
            puiIDDBuf = (unsigned int *)&ctrl;
            uiMask = puiIDDBuf[1015];
            if (uiMask == 0 || (aVendorLogs[i].ucLogPage == 0xE6 && uiMask == 2) ||
               (aVendorLogs[i].ucLogPage == 0xE7 && uiMask == 1)) {
                bSize = 0;
            } else {
                bSize = (int)puiIDDBuf[1023];
                if (bSize % (16 * 1024)) {
                    bSize += (16 * 1024) - (bSize % (16 * 1024));
                }
            }
            if (bSize != 0 && (dataBuffer = (unsigned char *)malloc(bSize)) != NULL) {
                memset(dataBuffer, 0, bSize);
                if (eModel == M5410 || eModel == M5407)
                    err = NVMEGetLogPage(fd, aVendorLogs[i].ucLogPage, dataBuffer, bSize);
                else
                    err = nvme_get_log(fd, NVME_NSID_ALL, aVendorLogs[i].ucLogPage,
                                       false, NVME_NO_LOG_LSP, bSize, dataBuffer);
            }
            break;

        case 0xF7:
        case 0xF9:
        case 0xFC:
        case 0xFD:
            if (eModel == M51BX)
                (void)NVMEResetLog(fd, aVendorLogs[i].ucLogPage,
                                   aVendorLogs[i].nLogSize, aVendorLogs[i].nMaxSize);
        default:
            bSize = aVendorLogs[i].nLogSize;
            dataBuffer = (unsigned char *)malloc(bSize);
            if (dataBuffer == NULL) {
               break;
            }
            memset(dataBuffer, 0, bSize);
            err = nvme_get_log(fd, NVME_NSID_ALL, aVendorLogs[i].ucLogPage,
                               false, NVME_NO_LOG_LSP, bSize, dataBuffer);
            maxSize = aVendorLogs[i].nMaxSize - bSize;
            while (err == 0 && maxSize > 0 && ((unsigned int *)dataBuffer)[0] != 0xdeadbeef) {
                sprintf(msg, "log 0x%x", aVendorLogs[i].ucLogPage);
                WriteData(dataBuffer, bSize, strCtrlDirName, aVendorLogs[i].strFileName, msg);
                err = nvme_get_log(fd, NVME_NSID_ALL, aVendorLogs[i].ucLogPage,
                                   false, NVME_NO_LOG_LSP, bSize, dataBuffer);
                if (err || (((unsigned int *)dataBuffer)[0] == 0xdeadbeef))
                    break;
                maxSize -= bSize;
            }
            break;
        }

        if (err == 0 && dataBuffer != NULL && ((unsigned int *)dataBuffer)[0] != 0xdeadbeef) {
            sprintf(msg, "log 0x%x", aVendorLogs[i].ucLogPage);
            WriteData(dataBuffer, bSize, strCtrlDirName, aVendorLogs[i].strFileName, msg);
        }

        if (dataBuffer != NULL) {
            free(dataBuffer);
            dataBuffer = NULL;
        }
    }

    err = ZipAndRemoveDir(strMainDirName, cfg.package);
out:
    return err;
}
