source: trunk/third/sysinfo/myscsi.c @ 12269

/*
 * Copyright (c) 1992-1998 Michael A. Cooper.
 * This software may be freely used and distributed provided it is not
 * sold for profit or used in part or in whole for commercial gain
 * without prior written agreement, and the author is credited
 * appropriately.
 */

#ifndef lint
static char *RCSid = "$Revision: 1.1.1.1 $";
#endif

/*
 * Common SysInfo SCSI functions
 */

#include "defs.h"
#include "myscsi.h"
#include <netinet/in.h>         /* For ntohs() etc. */

/*
 * Do setup for Scsi*Decode() funcs which need a DiskDrive_t to work on
 */
static DiskDrive_t *DiskSetup(DevInfo, What)
     DevInfo_t                 *DevInfo;
     char                      *What;
{
    DiskDriveData_t            *DiskDriveData;

    if (!DevInfo || !What)
        return((DiskDrive_t *) NULL);

    /*
     * We may want to add other DevType's as we discover them, but
     * right now we only know how to deal with DiskDrive's.
     */
    if (DevInfo->Type != DT_DISKDRIVE) {
        SImsg(SIM_DBG, "%s: %s unsupported for DevType %d",
              DevInfo->Name, What, DevInfo->Type);
        return((DiskDrive_t *) NULL);
    }

    /*
     * Find or create the DiskDriveData and DiskDrive we need
     */
    if (DevInfo->DevSpec)
        DiskDriveData = (DiskDriveData_t *) DevInfo->DevSpec;
    else {
        DiskDriveData = NewDiskDriveData(NULL);
        DevInfo->DevSpec = (void *) DiskDriveData;
    }
    if (!DiskDriveData->HWdata)
        DiskDriveData->HWdata = NewDiskDrive(NULL);

    return(DiskDriveData->HWdata);
}

/*
 * Decode a SCSI CAPACITY command and add info to DevInfo as we can.
 */
extern int ScsiCapacityDecode(Query)
    ScsiQuery_t                *Query;
{
    ScsiCapacity_t             *Capacity;
    DiskDrive_t                *Disk;
    DevInfo_t                  *DevInfo;

    if (!Query|| !Query->DevInfo || !Query->Data)
        return(-1);

    Capacity = (ScsiCapacity_t *) Query->Data;
    DevInfo = Query->DevInfo;

    SImsg(SIM_DBG, 
          "\t%s: SCSI CAPACITY: Blocks=<%d> BlockSize=<%d>",
          DevInfo->Name, ntohl(Capacity->Blocks), ntohl(Capacity->BlkSize));

    if (!(Disk = DiskSetup(DevInfo, "ScsiCapacityDecode")))
        return(-1);

    /*
     * Set what we know
     */
    Disk->Size = nsect_to_mbytes( ntohl(Capacity->Blocks),
                                  ntohl(Capacity->BlkSize) );
    Disk->SecSize = ntohl(Capacity->BlkSize);

    return(0);
}

/*
 * Decode a SCSI INQUIRY command and add info to DevInfo as we can.
 */
extern int ScsiInquiryDecode(Query)
    ScsiQuery_t                *Query;
{
    ScsiInquiry_t              *Inq;
    DevInfo_t                  *DevInfo;
    Define_t                   *Def;
    char                       *DevType = NULL;
    char                       *cp;

    if (!Query || !Query->Data || !Query->DevInfo) {
        SImsg(SIM_DBG, "ScsiInquiryDecode: Bad parameters");
        return(-1);
    }

    Inq = (ScsiInquiry_t *) Query->Data;
    DevInfo = Query->DevInfo;

    SImsg(SIM_DBG, 
          "\t%s: SCSI INQUIRY: vendor=<%.*s> product=<%.*s>",
          DevInfo->Name,
          sizeof(Inq->inq_vid), Inq->inq_vid, 
          sizeof(Inq->inq_pid), Inq->inq_pid);
    SImsg(SIM_DBG, 
          "\t%s: SCSI INQUIRY:    rev=<%.*s> serial=<%.*s>",
          DevInfo->Name,
          sizeof(Inq->inq_revision), Inq->inq_revision, 
          sizeof(Inq->inq_serial), Inq->inq_serial);

    /*
     * This is implied by this function being called
     */
    DevInfo->ClassType = CT_SCSI;

    /*
     * Decode results
     */
#define IsOk(s) ( s && s[0] && s[0] != ' ' && isalnum(s[0]) )
    if (IsOk(Inq->inq_vid))
        DevInfo->Vendor = CleanString(Inq->inq_vid, sizeof(Inq->inq_vid), 0);
    if (IsOk(Inq->inq_pid))
        DevInfo->Model = CleanString(Inq->inq_pid, sizeof(Inq->inq_pid), 0);
    if (IsOk(Inq->inq_revision))
        DevInfo->Revision = CleanString(Inq->inq_revision, 
                                        sizeof(Inq->inq_revision), 0);
    if (IsOk(Inq->inq_serial))
        DevInfo->Serial = CleanString(Inq->inq_serial, 
                                      sizeof(Inq->inq_serial), 0);
#undef IsOk
    /*
     * What SCSI version are we?
     */
    cp = NULL;
    switch ((int)Inq->inq_rdf) {
    case RDF_LEVEL0:    cp = "SCSI-1";  break;
    case RDF_SCSI2:     cp = "SCSI-2";  break;
    case RDF_CCS:       cp = "CCS";     break;
    }
    if (cp)
        AddDevDesc(DevInfo, cp, "SCSI Version/Protocol", DA_APPEND);
    else
        SImsg(SIM_UNKN, "Unknown RDF/SCSI Version 0x%x", 
              Inq->inq_rdf);

    /*
     * ANSI/ECMA/ISO version info
     */
    AddDevDesc(DevInfo, itoa(Inq->inq_ansi), "ANSI Version", DA_APPEND);
    AddDevDesc(DevInfo, itoa(Inq->inq_ecma), "ECMA Version", DA_APPEND);
    AddDevDesc(DevInfo, itoa(Inq->inq_iso), "ISO Version", DA_APPEND);

    /*
     * Check all the flag bits
     */
    if (Inq->inq_rmb)
        AddDevDesc(DevInfo, "Removable Media", "Has", DA_APPEND);
    if (Inq->inq_normaca)
        AddDevDesc(DevInfo, "Setting NACA bit", "Has", DA_APPEND);
    if (Inq->inq_trmiop)
        AddDevDesc(DevInfo, "TERMINATE I/O PROC msg", "Has", DA_APPEND);
    if (Inq->inq_aenc)
        AddDevDesc(DevInfo, "Async Event Notification", "Has", DA_APPEND);
    if (Inq->inq_wbus16)
        AddDevDesc(DevInfo, "Wide SCSI: 16-bit Data Transfers", 
                   "Has", DA_APPEND);
    if (Inq->inq_wbus32)
        AddDevDesc(DevInfo, "Wide SCSI: 32-bit Data Transfers", 
                   "Has", DA_APPEND);
    if (Inq->inq_addr16)
        AddDevDesc(DevInfo, "Wide SCSI: 16-bit Addressing", 
                   "Has", DA_APPEND);
    if (Inq->inq_addr32)
        AddDevDesc(DevInfo, "Wide SCSI: 32-bit Addressing", 
                   "Has", DA_APPEND);
    if (Inq->inq_ackqreqq)
        AddDevDesc(DevInfo, "Data Transfer on Q Cable", "Has", DA_APPEND);
    if (Inq->inq_mchngr)
        AddDevDesc(DevInfo, "Embedded/attached to medium changer", 
                   "Has", DA_APPEND);
    if (Inq->inq_dualp)
        AddDevDesc(DevInfo, "Dual Port Device", "Has", DA_APPEND);
    if (Inq->inq_trandis)
        AddDevDesc(DevInfo, "Transfer Disable Messages", "Has", DA_APPEND);
    if (Inq->inq_sftre)
        AddDevDesc(DevInfo, "Soft Reset option", "Has", DA_APPEND);
    if (Inq->inq_cmdque)
        AddDevDesc(DevInfo, "Command Queuing", "Has", DA_APPEND);
    if (Inq->inq_linked)
        AddDevDesc(DevInfo, "Linked Commands", "Has", DA_APPEND);
    if (Inq->inq_sync)
        AddDevDesc(DevInfo, "Syncronous Data Transfers", "Has", DA_APPEND);
    if (Inq->inq_reladdr)
        AddDevDesc(DevInfo, "Relative Addressing", "Has", DA_APPEND);

    /*
     * Look up device type
     */
    Def = DefGet(DL_SCSI_DTYPE, (char *) NULL, (long) Inq->inq_dtype, 0);
    if (Def) {
        /*
         * Set Device Type 
         */
        if (Def->ValStr1) {
            DevType_t           *dtPtr;

            dtPtr = TypeGetByName(Def->ValStr1);
            if (dtPtr)
                DevInfo->Type = dtPtr->Type;
            else
                SImsg(SIM_DBG, "%s: SCSIdtype DevType=<%s> is unknown.",
                      DevInfo->Name, Def->ValStr1);
        }
    } else
        SImsg(SIM_DBG, "%s: Unknown SCSIdtype=0x%02x", 
              DevInfo->Name, Inq->inq_dtype);

    return(0);
}
     
/*
 * Get description info about SCSI devices by sending a SCSI INQUIRY
 * to the device.
 */
extern int ScsiQueryInquiry(Query)
     ScsiQuery_t               *Query;
{
    static ScsiCdbG0_t          Cdb;
    static ScsiCmd_t            Cmd;

    if (!Query) {
        SImsg(SIM_DBG, "ScsiInquiry: Bad parameters");
        return(-1);
    }

    /*
     * Initialize
     */
    memset(&Cdb, 0, sizeof(Cdb));
    Cdb.cmd = CMD_INQUIRY;
    Cdb.length = sizeof(ScsiInquiry_t);

    memset(&Cmd, 0, sizeof(Cmd));
    Cmd.Cdb = &Cdb;
    Cmd.CdbLen = sizeof(Cdb);
    Cmd.DevFD = Query->DevFD;
    Cmd.DevFile = Query->DevFile;

    if (ScsiCmd(&Cmd) == 0) {
        /*
         * Decode results
         */
        Query->Data = Cmd.Data;
        return ScsiInquiryDecode(Query);
    } else
        return(-1);
}

/*
 * Get description info about SCSI devices by sending a SCSI CAPACITY
 * to the device.
 */
extern int ScsiQueryCapacity(Query)
     ScsiQuery_t               *Query;  
{
    static ScsiCdbG1_t          Cdb;
    static ScsiCmd_t            Cmd;

    if (!Query) {
        SImsg(SIM_DBG, "ScsiCapacity: Bad parameters");
        return(-1);
    }

    /*
     * Initialize
     */
    memset(&Cdb, 0, sizeof(Cdb));
    Cdb.cmd = CMD_CAPACITY;

    memset(&Cmd, 0, sizeof(Cmd));
    Cmd.Cdb = &Cdb;
    Cmd.CdbLen = sizeof(Cdb);
    Cmd.DevFD = Query->DevFD;
    Cmd.DevFile = Query->DevFile;

    if (ScsiCmd(&Cmd) == 0) {
        /*
         * Decode results
         */
        Query->Data = Cmd.Data;
        return ScsiCapacityDecode(Query);
    } else
        return(-1);
}

/*
 * Decode a SCSI GEOMETRY command and add info to DevInfo as we can.
 */
extern int ScsiGeometryDecode(Query)
    ScsiQuery_t                *Query;
{
    ScsiModeGeometry_t         *Geometry;
    DiskDrive_t                *Disk;
    DevInfo_t                  *DevInfo;

    if (!Query|| !Query->DevInfo || !Query->Data)
        return(-1);

    Geometry = (ScsiModeGeometry_t *) Query->Data;
    DevInfo = Query->DevInfo;

    SImsg(SIM_DBG, 
          "\t%s: SCSI GEOMETRY: #tracks=<%d>",
          DevInfo->Name, Geometry->heads);

    if (!(Disk = DiskSetup(DevInfo, "ScsiGeometryDecode")))
        return(-1);

    Disk->Tracks = Geometry->heads;
    Disk->PhyCyl = (int)(Geometry->cyl_ub << 16) + (int)(Geometry->cyl_mb << 8)
        + (int)(Geometry->cyl_lb);
    Disk->RPM = ntohs(Geometry->rpm);

    return(0);
}

/*
 * Decode a SCSI FORMAT command and add info to DevInfo as we can.
 */
extern int ScsiFormatDecode(Query)
    ScsiQuery_t                *Query;
{
    ScsiModeFormat_t           *Format;
    DiskDrive_t                *Disk;
    DevInfo_t                  *DevInfo;

    if (!Query|| !Query->DevInfo || !Query->Data)
        return(-1);

    Format = (ScsiModeFormat_t *) Query->Data;
    DevInfo = Query->DevInfo;

    SImsg(SIM_DBG, 
          "\t%s: SCSI FORMAT: #sect=<%d> secsize=<%d>",
          DevInfo->Name, ntohs(Format->sect_track), 
          ntohs(Format->data_bytes_sect));

    if (!(Disk = DiskSetup(DevInfo, "ScsiFormatDecode")))
        return(-1);

    Disk->Sect = ntohs(Format->sect_track);
    Disk->SecSize = ntohs(Format->data_bytes_sect);
    Disk->Tracks = ntohs(Format->tracks_per_zone);
    Disk->AltSectPerZone = ntohs(Format->alt_sect_zone);
    Disk->AltTracksPerVol = ntohs(Format->alt_tracks_vol);
    Disk->AltTracksPerZone = ntohs(Format->alt_tracks_zone);
    Disk->IntrLv = ntohs(Format->interleave);
    Disk->TrackSkew = ntohs(Format->track_skew);
    Disk->CylSkew = ntohs(Format->cylinder_skew);

    return(0);
}

/*
 * Get description info about SCSI devices by sending a SCSI FORMAT
 * to the device.
 */
extern int ScsiQueryFormat(Query)
     ScsiQuery_t               *Query;  
{
    static ScsiCdbG0_t          Cdb;
    static ScsiCmd_t            Cmd;
    static ScsiModeFormat_t     Format;
    ScsiModeHeader_t           *Hdr;
    char                       *LocPtr;

    if (!Query) {
        SImsg(SIM_DBG, "ScsiFormat: Bad parameters");
        return(-1);
    }

    /*
     * Initialize
     */
    memset(&Cdb, 0, sizeof(Cdb));
    Cdb.cmd = CMD_MODE_SENSE;
    Cdb.addr1 = DAD_MODE_FORMAT;
    Cdb.length = 255;   /* Yuck.  It's hardcoded */

    memset(&Cmd, 0, sizeof(Cmd));
    Cmd.Cdb = &Cdb;
    Cmd.CdbLen = sizeof(Cdb);
    Cmd.DevFD = Query->DevFD;
    Cmd.DevFile = Query->DevFile;

    if (ScsiCmd(&Cmd) == 0) {
        /*
         * Decode results
         */
        Hdr = (ScsiModeHeader_t *) Cmd.Data;
        LocPtr = SCSI_MODE_PAGE_ADDR(Hdr, char);
        (void) memset(&Format, 0, sizeof(Format));
        (void) memcpy(&Format, LocPtr, sizeof(ScsiModePage_t));
        (void) memcpy(&Format, LocPtr, Format.mode_page.length);
        Query->Data = (void *) &Format;
        return ScsiFormatDecode(Query);
    } else
        return(-1);
}

/*
 * Get description info about SCSI devices by sending a SCSI GEOMETRY
 * to the device.
 */
extern int ScsiQueryGeometry(Query)
     ScsiQuery_t               *Query;  
{
    static ScsiCdbG0_t          Cdb;
    static ScsiCmd_t            Cmd;
    static ScsiModeGeometry_t   Geometry;
    ScsiModeHeader_t           *Hdr;
    char                       *LocPtr;

    if (!Query) {
        SImsg(SIM_DBG, "ScsiGeometry: Bad parameters");
        return(-1);
    }

    /*
     * Initialize
     */
    memset(&Cdb, 0, sizeof(Cdb));
    Cdb.cmd = CMD_MODE_SENSE;
    Cdb.addr1 = DAD_MODE_GEOMETRY;
    Cdb.length = 255;   /* Yuck.  It's hardcoded */

    memset(&Cmd, 0, sizeof(Cmd));
    Cmd.Cdb = &Cdb;
    Cmd.CdbLen = sizeof(Cdb);
    Cmd.DevFD = Query->DevFD;
    Cmd.DevFile = Query->DevFile;

    if (ScsiCmd(&Cmd) == 0) {
        /*
         * Decode results
         */
        Hdr = (ScsiModeHeader_t *) Cmd.Data;
        LocPtr = SCSI_MODE_PAGE_ADDR(Hdr, char);
        (void) memset(&Geometry, 0, sizeof(Geometry));
        (void) memcpy(&Geometry, LocPtr, sizeof(ScsiModePage_t));
        (void) memcpy(&Geometry, LocPtr, Geometry.mode_page.length);
        Query->Data = (void *) &Geometry;
        return ScsiGeometryDecode(Query);
    } else
        return(-1);
}

/*
 * Decode a SCSI SPEED command and add info to DevInfo as we can.
 */
extern int ScsiSpeedDecode(Query)
    ScsiQuery_t                *Query;
{
    ScsiModeSpeed_t            *Speed;
    DevInfo_t                  *DevInfo;

    if (!Query|| !Query->DevInfo || !Query->Data)
        return(-1);

    Speed = (ScsiModeSpeed_t *) Query->Data;
    DevInfo = Query->DevInfo;

    SImsg(SIM_DBG, 
          "\t%s: SCSI SPEED: speed=<%d>",
          DevInfo->Name, ntohs(Speed->speed));

    /*
     * XXX Don't know how useful this will be or what the "speed" values
     * will be, so for now, we just print a debug.
     */

    return(0);
}

/*
 * Get the speed of a SCSI device.
 * This only works on CD-ROM's right now.
 */
extern int ScsiQuerySpeed(Query)
     ScsiQuery_t               *Query;  
{
    static ScsiCdbG0_t          Cdb;
    static ScsiCmd_t            Cmd;
    static ScsiModeSpeed_t      Speed;
    ScsiModeHeader_t           *Hdr;
    char                       *LocPtr;

    if (!Query) {
        SImsg(SIM_DBG, "ScsiSpeed: Bad parameters");
        return(-1);
    }

    if (Query->DevInfo && Query->DevInfo->Type != DT_CDROM) {
        SImsg(SIM_DBG, "%s: Not a CDROM (%d).  Skipping ScsiQuerySpeed.",
              Query->DevInfo->Name, Query->DevInfo->Type);
        return(-1);
    }

    /*
     * Initialize
     */
    memset(&Cdb, 0, sizeof(Cdb));
    Cdb.cmd = CMD_MODE_SENSE;
    Cdb.addr1 = CDROM_MODE_SPEED;
    Cdb.length = 255;   /* Yuck.  It's hardcoded */

    memset(&Cmd, 0, sizeof(Cmd));
    Cmd.Cdb = &Cdb;
    Cmd.CdbLen = sizeof(Cdb);
    Cmd.DevFD = Query->DevFD;
    Cmd.DevFile = Query->DevFile;

    if (ScsiCmd(&Cmd) == 0) {
        /*
         * Decode results
         */
        Hdr = (ScsiModeHeader_t *) Cmd.Data;
        LocPtr = SCSI_MODE_PAGE_ADDR(Hdr, char);
        (void) memset(&Speed, 0, sizeof(Speed));
        (void) memcpy(&Speed, LocPtr, sizeof(ScsiModePage_t));
        (void) memcpy(&Speed, LocPtr, Speed.mode_page.length);
        Query->Data = (void *) &Speed;
        return ScsiSpeedDecode(Query);
    } else
        return(-1);
}

/*
 * Query a device for SCSI information.
 */
extern int ScsiQuery(DevInfo, DevFile, DevFD, OverRide)
    DevInfo_t                  *DevInfo;
    char                       *DevFile;
    int                         DevFD;
    int                         OverRide;
{
    int                         Status = 0;
    int                         Type = 0;
    static ScsiQuery_t          Query;
    int                         fd = -1;

    if (!DevInfo || !DevFile) {
        SImsg(SIM_DBG, "ScsiQuery: Bad parameters.");
        return(-1);
    }

    if (DevFD < 0) {
        /*
         * We use O_RDWR because many OS's require Write perms
         */
        DevFD = fd = open(DevFile, O_RDWR|O_NDELAY|O_NONBLOCK);
        if (fd < 0) {
            SImsg(SIM_GERR, "%s: ScsiQuery: open for read failed: %s",
                  DevFile, SYSERR);
            return(-1);
        }
    }

    (void) memset(&Query, 0, sizeof(Query));
    Query.DevInfo = DevInfo;
    Query.DevFile = DevFile;
    Query.DevFD = DevFD;
    Query.OverRide = OverRide;

    /* Insure DevInfo->Name is valid */
    if (!Query.DevInfo->Name)
        Query.DevInfo->Name = DevFile;

    /*
     * We expect that after ScsiQueryInquire() DevInfo->Type will
     * be correctly set.
     */
    if (ScsiQueryInquiry(&Query) < 0)
        --Status;

    /*
     * For the rest of these, only try the Query if Type is not
     * set or if the Type is set to an appropriate device type
     */
    Type = Query.DevInfo->Type;
    if (!Type || Type == DT_DISKDRIVE || Type == DT_CDROM) {
        if (ScsiQueryCapacity(&Query) < 0)
            --Status;
        if (ScsiQueryFormat(&Query) < 0)
            --Status;
        if (ScsiQueryGeometry(&Query) < 0)
            --Status;
    }
    if (!Type || Type == DT_CDROM) {
        if (ScsiQuerySpeed(&Query) < 0)
            --Status;
    }

    /*
     * If we opened the descriptor, then close it now
     */
    if (fd >= 0)
        (void) close(fd);

    /*
     * If all Scsi*() functions returned error, we return error.
     * If at least 1 function succeeded, we return success.
     */
    if (Status == -5)   /* XXX change to be count of ScsiQuery*() above */
        return(-1);
    else
        return(0);
}