/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <ctype.h>
#include <printAttrs.h>

static SAS_STATE hbastatus_string[] = {
        HBA_STATUS_OK,                          "Okay",
        HBA_STATUS_ERROR,                       "Error",
        HBA_STATUS_ERROR_NOT_SUPPORTED,         "Not Supported",
        HBA_STATUS_ERROR_INVALID_HANDLE,        "Invalid Handle",
        HBA_STATUS_ERROR_ARG,                   "Argument Error",
        HBA_STATUS_ERROR_ILLEGAL_WWN,           "Illegal WWN",
        HBA_STATUS_ERROR_ILLEGAL_INDEX,         "Illegal Index",
        HBA_STATUS_ERROR_MORE_DATA,             "Not Enough Buffer for Data",
        HBA_STATUS_ERROR_STALE_DATA,            "Stale Data",
        HBA_STATUS_SCSI_CHECK_CONDITION,        "SCSI Check Condition",
        HBA_STATUS_ERROR_BUSY,                  "Busy",
        HBA_STATUS_ERROR_TRY_AGAIN,             "Try Again",
        HBA_STATUS_ERROR_UNAVAILABLE,           "Unavailable",
        HBA_STATUS_ERROR_ELS_REJECT,            "ELS Reject",
        HBA_STATUS_ERROR_INVALID_LUN,           "Invalid LUN",
        HBA_STATUS_ERROR_INCOMPATIBLE,          "Request Incompatible",
        HBA_STATUS_ERROR_AMBIGUOUS_WWN,         "Ambiguous WWN",
        HBA_STATUS_ERROR_LOCAL_BUS,             "Local Bus Error",
        HBA_STATUS_ERROR_LOCAL_TARGET,          "Local Target Error",
        HBA_STATUS_ERROR_LOCAL_LUN,             "Local LUN Error",
        HBA_STATUS_ERROR_LOCAL_SCSIID_BOUND,    "Local SCSIID Bound",
        HBA_STATUS_ERROR_TARGET_FCID,           "Target FCID Error",
        HBA_STATUS_ERROR_TARGET_NODE_WWN,       "Target Node WWN Error",
        HBA_STATUS_ERROR_TARGET_PORT_WWN,       "Target Port WWN Error",
        HBA_STATUS_ERROR_TARGET_LUN,            "Target LUN Error",
        HBA_STATUS_ERROR_TARGET_LUID,           "Target LUID Error",
        HBA_STATUS_ERROR_NO_SUCH_BINDING,       "No Such Binding",
        HBA_STATUS_ERROR_NOT_A_TARGET,          "Not a Target",
        HBA_STATUS_ERROR_UNSUPPORTED_FC4,       "Unsupported FC4",
        HBA_STATUS_ERROR_INCAPABLE,             "Incapable",
        HBA_STATUS_ERROR_TARGET_BUSY,           "Target Busy",
        HBA_STATUS_ERROR_NOT_LOADED,            "Not Loaded",
        HBA_STATUS_ERROR_ALREADY_LOADED,        "Alreday Loaded",
        HBA_STATUS_ERROR_ILLEGAL_FCID,          "Illegal FCID",
        HBA_STATUS_ERROR_NOT_ASCSIDEVICE,       "Not a SCSI Device",
        HBA_STATUS_ERROR_INVALID_PROTOCOL_TYPE, "Invalid Protocol Type",
        HBA_STATUS_ERROR_BAD_EVENT_TYPE,        "Bad Event Type",
        -1,                                     NULL
};

SAS_STATE porttype_string[] = {
        HBA_PORTTYPE_UNKNOWN,           "UNKNOWN",
        HBA_PORTTYPE_OTHER,             "OTHER",
        HBA_PORTTYPE_NOTPRESENT,        "NOT Present",
        HBA_PORTTYPE_SASDEVICE,         "SAS Device",
        HBA_PORTTYPE_SATADEVICE,        "SATA Device",
        HBA_PORTTYPE_SASEXPANDER,       "SAS Expander",
        -1,                             NULL,
};

SAS_STATE portstate_string[] = {
        HBA_PORTSTATE_UNKNOWN,          "unknown",
        HBA_PORTSTATE_ONLINE,           "online",
        HBA_PORTSTATE_OFFLINE,          "offline",
        HBA_PORTSTATE_BYPASSED,         "bypassed",
        HBA_PORTSTATE_DIAGNOSTICS,      "diagnostics",
        HBA_PORTSTATE_LINKDOWN,         "link Down",
        HBA_PORTSTATE_ERROR,            "port Error",
        HBA_PORTSTATE_LOOPBACK,         "loopback",
        HBA_PORTSTATE_DEGRADED,         "degraded",
        -1,                             NULL,
};

static SAS_STATE phystate_string[] = {
        HBA_SASSTATE_UNKNOWN,           "unknown",
        HBA_SASSTATE_DISABLED,          "disabled",
        HBA_SASSTATE_FAILED,            "failed",
        HBA_SASSTATE_SATASPINUP,        "sata-spinup",
        HBA_SASSTATE_SATAPORTSEL,       "sata-portselector",
        HBA_SASSPEED_1_5GBIT,           "1.5Gbit",
        HBA_SASSPEED_3GBIT,             "3Gbit",
        HBA_SASSPEED_6GBIT,             "6Gbit",
        HBA_SASSPEED_12GBIT,            "12Gbit",
        -1,                             NULL,
};

static SAS_STATE dtype_string[] = {
        DTYPE_DIRECT,                   "Disk Device",
        DTYPE_SEQUENTIAL,               "Tape Device",
        DTYPE_PRINTER,                  "Printer Device",
        DTYPE_PROCESSOR,                "Processor Device",
        DTYPE_WORM,                     "WORM Device",
        DTYPE_RODIRECT,                 "CD/DVD Device",
        DTYPE_SCANNER,                  "Scanner Device",
        DTYPE_OPTICAL,                  "Optical Memory Device",
        DTYPE_CHANGER,                  "Medium Changer Device",
        DTYPE_COMM,                     "Communications Device",
        DTYPE_ARRAY_CTRL,               "Storage Array Controller Device",
        DTYPE_ESI,                      "Enclosure Services Device",
        DTYPE_RBC,                      "Simplified Direct-access Device",
        DTYPE_OCRW,                     "Optical Card Reader/Writer Device",
        DTYPE_BCC,                      "Bridge Controller Commands",
        DTYPE_OSD,                      "Object-based Storage Device",
        DTYPE_ADC,                      "Automation/Drive Interface",
        DTYPE_WELLKNOWN,                "Well Known Logical Unit",
        DTYPE_UNKNOWN,                  "Unknown Device",
        -1,                             NULL
};

static char *getPhyStateString(HBA_UINT32 key, phystat_type phyt);

char *
getIndentSpaces(int number)
{
        int             i = 0;
        /* the maximum indent with terminator '\0' */
        static char     ret[MAXINDENT+1];

        if (number > MAXINDENT)
                number = MAXINDENT;

        for (i = 0; i < number; i++) {
                ret[i] = ' ';
        }
        ret[i] = '\0';
        return (ret);
}

char *
getStateString(HBA_UINT32 key, SAS_STATE *stat_string)
{
        static char ret[64];
        while (stat_string->key != -1) {
                if (stat_string->key == key) {
                        return ((char *)stat_string->value);
                }
                stat_string++;
        }
        (void) sprintf(ret, "Undefined value (%d)", key);
        return (ret);
}

static char *
getPhyStateString(HBA_UINT32 key, phystat_type phyt)
{
        int i = 0, len = 0, match = 0;
        HBA_UINT32 physpeed[] = {
                HBA_SASSPEED_1_5GBIT,
                HBA_SASSPEED_3GBIT,
                HBA_SASSPEED_6GBIT,
                HBA_SASSPEED_12GBIT
        };

        len = sizeof (physpeed) / sizeof (HBA_UINT32);
        for (i = 0; i < len; i++) {
                if (key == physpeed[i]) {
                        match = 1;
                        break;
                }
        }

        if (match == 1) {
                if (phyt == PHY_STATE)
                        return ("enabled");
                else
                        return (getStateString(key, phystate_string));
        } else {
                if (phyt == PHY_STATE)
                        return (getStateString(key, phystate_string));
                else
                        return ("not available");
        }
}

char *
getHBAStatus(HBA_STATUS key)
{
        return (getStateString(key, hbastatus_string));
}

/*
 * return device type description
 *
 * Arguments:
 *      dType - Device type returned from Standard INQUIRY
 * Returns:
 *      char string description for device type
 */
char *
getDTypeString(uchar_t dType)
{
        return (getStateString((dType & DTYPE_MASK), dtype_string));
}

uint64_t
wwnConversion(uchar_t *wwn)
{
        uint64_t tmp;
        (void) memcpy(&tmp, wwn, sizeof (uint64_t));
        return (ntohll(tmp));
}

/*
 * prints out HBA information
 */
void
printHBAInfo(SMHBA_ADAPTERATTRIBUTES *attrs, int pflag, int numberOfPorts,
    const char *adapterName)
{

        (void) fprintf(stdout, "%s %s\n", "HBA Name:", adapterName);

        if (pflag & PRINT_VERBOSE) {
                (void) fprintf(stdout, "%s%s %s\n",
                    getIndentSpaces(4), "Manufacturer:",
                    attrs->Manufacturer[0] == 0?
                    "not available":attrs->Manufacturer);
                (void) fprintf(stdout, "%s%s %s\n",
                    getIndentSpaces(4), "Model: ",
                    attrs->Model[0] == 0? "not available":attrs->Model);
                (void) fprintf(stdout, "%s%s %s\n",
                    getIndentSpaces(4),
                    "Firmware Version:",
                    attrs->FirmwareVersion[0] == 0? "not available":
                    attrs->FirmwareVersion);
                (void) fprintf(stdout, "%s%s %s\n",
                    getIndentSpaces(4),
                    "FCode/BIOS Version:",
                    attrs->OptionROMVersion[0] == 0? "not available":
                    attrs->OptionROMVersion);
                (void) fprintf(stdout, "%s%s %s\n",
                    getIndentSpaces(4),
                    "Serial Number:",
                    attrs->SerialNumber[0] == 0? "not available":
                    attrs->SerialNumber);
                (void) fprintf(stdout, "%s%s %s\n",
                    getIndentSpaces(4),
                    "Driver Name:",
                    attrs->DriverName[0] == 0? "not available":
                    attrs->DriverName);
                (void) fprintf(stdout, "%s%s %s\n",
                    getIndentSpaces(4),
                    "Driver Version:",
                    attrs->DriverVersion[0] == 0? "not available":
                    attrs->DriverVersion);
                (void) fprintf(stdout, "%s%s %d\n",
                    getIndentSpaces(4),
                    "Number of HBA Ports:",
                    numberOfPorts);
        }
}

/*
 * prints out all the HBA port information
 */
void
printHBAPortInfo(SMHBA_PORTATTRIBUTES *port,
    SMHBA_ADAPTERATTRIBUTES *attrs, int pflag) {

        if ((port == NULL) || (attrs == NULL)) {
                return;
        }

        (void) fprintf(stdout, "%s%s %s\n",
            getIndentSpaces(2),
            "HBA Port Name:",
            port->OSDeviceName);

        if (!(pflag & PRINT_VERBOSE)) {
                return;
        }

        if (port->PortType != HBA_PORTTYPE_SASDEVICE)
                return;

        (void) fprintf(stdout, "%s%s %s\n",
            getIndentSpaces(4),
            "Type:",
            getStateString(port->PortType, porttype_string));
        (void) fprintf(stdout, "%s%s %s\n",
            getIndentSpaces(4),
            "State:",
            getStateString(port->PortState, portstate_string));

        (void) fprintf(stdout, "%s%s %016llx\n",
            getIndentSpaces(4),
            "Local SAS Address:",
            wwnConversion(port->PortSpecificAttribute.SASPort->\
            LocalSASAddress.wwn));

        (void) fprintf(stdout, "%s%s %016llx\n",
            getIndentSpaces(4),
            "Attached SAS Address:",
            wwnConversion(port->PortSpecificAttribute.SASPort->\
            AttachedSASAddress.wwn));

        (void) fprintf(stdout, "%s%s %d\n",
            getIndentSpaces(4),
            "Number of Phys:",
            port->PortSpecificAttribute.SASPort->NumberofPhys);
}

void
printHBAPortPhyInfo(SMHBA_SAS_PHY *phyinfo)
{
        if (phyinfo == NULL)
                return;

        (void) fprintf(stdout, "%s%s %u\n",
            getIndentSpaces(6),
            "Identifier:",
            phyinfo->PhyIdentifier);

        (void) fprintf(stdout, "%s%s %s\n",
            getIndentSpaces(8),
            "State: ",
            getPhyStateString(phyinfo->NegotiatedLinkRate, PHY_STATE));
        (void) fprintf(stdout, "%s%s %s/%s\n",
            getIndentSpaces(8),
            "HardwareLinkRate(Min/Max):",
            getPhyStateString(phyinfo->HardwareMinLinkRate, PHY_SPEED),
            getPhyStateString(phyinfo->HardwareMaxLinkRate, PHY_SPEED));
        (void) fprintf(stdout, "%s%s %s/%s\n",
            getIndentSpaces(8),
            "ProgrammedLinkRate(Min/Max):",
            getPhyStateString(phyinfo->ProgrammedMinLinkRate, PHY_SPEED),
            getPhyStateString(phyinfo->ProgrammedMaxLinkRate, PHY_SPEED));
        (void) fprintf(stdout, "%s%s %s\n",
            getIndentSpaces(8),
            "NegotiatedLinkRate:",
            getPhyStateString(phyinfo->NegotiatedLinkRate, PHY_SPEED));
}

void
printHBAPortPhyStatistics(SMHBA_SASPHYSTATISTICS *phystat)
{
        if (phystat == NULL)
                return;

        (void) fprintf(stdout, "%s%s\n",
            getIndentSpaces(8),
            "Link Error Statistics:");
        (void) fprintf(stdout, "%s%s %llu\n",
            getIndentSpaces(12),
            "Invalid Dword:",
            phystat->InvalidDwordCount);
        (void) fprintf(stdout, "%s%s %llu\n",
            getIndentSpaces(12),
            "Running Disparity Error:",
            phystat->RunningDisparityErrorCount);
        (void) fprintf(stdout, "%s%s %llu\n",
            getIndentSpaces(12),
            "Loss of Dword Sync:",
            phystat->LossofDwordSyncCount);
        (void) fprintf(stdout, "%s%s %llu\n",
            getIndentSpaces(12),
            "Reset Problem:",
            phystat->PhyResetProblemCount);
}

/*
 * print the OS device name for the logical-unit object
 *
 * Arguments:
 *      devListWalk - OS device path info
 *      verbose - boolean indicating whether to display additional info
 *
 * returns:
 *      0 - we're good.
 *      >0 - we met issues.
 */
int
printTargetPortInfo(targetPortList_t *TPListWalk, int pflag)
{
        targetPortConfig_t      *configList;
        targetPortMappingData_t *mapList;
        int                     count, i;
        int                     ret = 0;

        (void) fprintf(stdout, "Target Port SAS Address: %016llx\n",
            wwnConversion(TPListWalk->sasattr.LocalSASAddress.wwn));
        if ((pflag & PRINT_VERBOSE) || (pflag & PRINT_TARGET_SCSI)) {
                (void) fprintf(stdout, "%sType: %s\n", getIndentSpaces(4),
                    getStateString(TPListWalk->targetattr.PortType,
                    porttype_string));
                for (configList = TPListWalk->configEntry;
                    configList != NULL; configList = configList->next) {
                        (void) fprintf(stdout, "%sHBA Port Name: %s\n",
                            getIndentSpaces(4), configList->hbaPortName);
                        if (wwnConversion(configList->expanderSASAddr.wwn) !=
                            0) {
                                if (configList->expanderValid) {
                                        (void) fprintf(stdout,
                                            "%sExpander Device SAS Address:"
                                            " %016llx",
                                            getIndentSpaces(8),
                                            wwnConversion(configList->
                                            expanderSASAddr.wwn));
                                } else {
                                        (void) fprintf(stdout,
                                            "%sExpander Device SAS Address:"
                                            " %016llx (Failed to Validate"
                                            " Attached Port.)",
                                            getIndentSpaces(8),
                                            wwnConversion(configList->
                                            expanderSASAddr.wwn));
                                        ret++;
                                }
                        } else {
                                if (configList->expanderValid) {
                                        (void) fprintf(stdout,
                                            "%sExpander Device SAS Address: %s",
                                            getIndentSpaces(8),
                                            "None (direct attached)");
                                } else {
                                        (void) fprintf(stdout,
                                            "%sExpander Device SAS Address: %s",
                                            getIndentSpaces(8),
                                            "None (Failed to Get"
                                            " Attached Port)");
                                }
                        }
                        (void) fprintf(stdout, "\n");
                        if (pflag & PRINT_TARGET_SCSI) {

                                if (configList->reportLUNsFailed) {
                                        (void) fprintf(stdout,
                                            "%s %016llx\n",
                                            gettext("Error: Failed to get "
                                            "ReportLun Data on"),
                                            wwnConversion(TPListWalk->
                                            sasattr.LocalSASAddress.wwn));
                                        ret++;
                                        continue;
                                }

                                for (mapList = configList->map;
                                    mapList != NULL; mapList = mapList->next) {
                                        (void) fprintf(stdout, "%sLUN : %d\n",
                                            getIndentSpaces(12),
                                            mapList->osLUN);
                                        if (mapList->mappingExist) {
                                                (void) fprintf(stdout,
                                                    "%sOS Device Name : %s\n",
                                                    getIndentSpaces(14),
                                                    (mapList->osDeviceName[0] ==
                                                    '\0') ?  "Not avaialble" :
                                                    mapList->osDeviceName);
                                        } else {
                                                (void) fprintf(stdout,
                                                    "%sOS Device Name : %s\n",
                                                    getIndentSpaces(14), "No "
                                                    "matching OS Device "
                                                    "found.");
                                                ret++;
                                        }
                /* indentation changed here */
                if (mapList->inquiryFailed) {
                        (void) fprintf(stdout, "%s %s LUN %d\n",
                            gettext("Error: Failed to get Inquiry Data on"),
                            mapList->osDeviceName, mapList->osLUN);
                        ret++;
                } else {
                        (void) fprintf(stdout, "%sVendor: ",
                            getIndentSpaces(14));
                        for (count = sizeof (mapList->inq_vid), i = 0;
                            i < count; i++) {
                                if (isprint(mapList->inq_vid[i]))
                                        (void) fprintf(stdout, "%c",
                                            mapList->inq_vid[i]);
                        }

                        (void) fprintf(stdout, "\n%sProduct: ",
                            getIndentSpaces(14));
                        for (count = sizeof (mapList->inq_pid), i = 0;
                            i < count; i++) {
                                if (isprint(mapList->inq_pid[i]))
                                        (void) fprintf(stdout, "%c",
                                            mapList->inq_pid[i]);
                        }

                        (void) fprintf(stdout, "\n%sDevice Type: %s\n",
                            getIndentSpaces(14),
                            getDTypeString(mapList->inq_dtype));
                }
                /* indentation changed back */
                                }
                        }
                }
        }
        return (ret);
}

/*
 * print the OS device name for the logical-unit object
 *
 * Arguments:
 *      devListWalk - OS device path info
 *      verbose - boolean indicating whether to display additional info
 *
 * returns:
 *      0 - we're good.
 *      >0 - we met issues.
 */
int
printOSDeviceNameInfo(discoveredDevice *devListWalk, boolean_t verbose)
{
        portList                *portElem;
        tgtPortWWNList          *tgtWWNList;
        int                     i, count;
        int                     ret = 0;

        (void) fprintf(stdout, "OS Device Name: %s\n",
            devListWalk->OSDeviceName);
        if (verbose == B_TRUE) {
                for (portElem = devListWalk->HBAPortList;
                    portElem != NULL; portElem = portElem->next) {
                        (void) fprintf(stdout, "%sHBA Port Name: ",
                            getIndentSpaces(4));
                        (void) fprintf(stdout, "%s", portElem->portName);
                        for (tgtWWNList = portElem->tgtPortWWN;
                            tgtWWNList != NULL; tgtWWNList = tgtWWNList->next) {
                                (void) fprintf(stdout,
                                    "\n%sTarget Port SAS Address: ",
                                    getIndentSpaces(8));
                                (void) fprintf(stdout, "%016llx",
                                    wwnConversion(tgtWWNList->portWWN.wwn));
                                (void) fprintf(stdout, "\n%sLUN: %u",
                                    getIndentSpaces(12),
                                    tgtWWNList->scsiOSLun);
                        }
                        (void) fprintf(stdout, "\n");
                }

                if (devListWalk->inquiryFailed) {
                        (void) fprintf(stdout, "%s %s\n",
                            gettext("Error: Failed to get Inquiry data "
                            "on device"), devListWalk->OSDeviceName);
                        ret++;
                } else {
                        (void) fprintf(stdout, "%sVendor: ",
                            getIndentSpaces(4));
                        for (count = sizeof (devListWalk->VID), i = 0;
                            i < count; i++) {
                                if (isprint(devListWalk->VID[i]))
                                        (void) fprintf(stdout, "%c",
                                            devListWalk->VID[i]);
                        }

                        (void) fprintf(stdout, "\n%sProduct: ",
                            getIndentSpaces(4));
                        for (count = sizeof (devListWalk->PID), i = 0;
                            i < count; i++) {
                                if (isprint(devListWalk->PID[i]))
                                        (void) fprintf(stdout, "%c",
                                            devListWalk->PID[i]);
                        }

                        (void) fprintf(stdout, "\n%sDevice Type: %s\n",
                            getIndentSpaces(4),
                            getDTypeString(devListWalk->dType));
                }
        }
        return (ret);
}