megaraid.h

Linux内核源代码 为压缩文件 是<<Linux内核>>一书中的源代码

    u8   ldrvStateOld;   /* old state */

    u8   pdrvStateCounter;   /* Indicates change of ldrv state */
    u8   pdrvStateId;    /* pdrv id */
    u8   pdrvStateNew;   /* New state */
    u8   pdrvStateOld;   /* old state */

    u8   pdrvFmtCounter; /* Indicates pdrv format started/over */
    u8   pdrvFmtId;      /* pdrv id */
    u8   pdrvFmtVal;     /* format started/over */
    u8   pdrvFmtRsvd;

    u8   targXferCounter;    /* Indicates SCSI-2 Xfer rate change */
    u8   targXferId;     /* pdrv Id  */
    u8   targXferVal;    /* new Xfer params of last pdrv */
    u8   targXferRsvd;

    u8   fcLoopIdChgCounter; /* Indicates loopid changed */
    u8   fcLoopIdPdrvId; /* pdrv id */
    u8   fcLoopId0;      /* loopid on fc loop 0 */
    u8   fcLoopId1;      /* loopid on fc loop 1 */

    u8   fcLoopStateCounter; /* Indicates loop state changed */
    u8   fcLoopState0;   /* state of fc loop 0 */
    u8   fcLoopState1;   /* state of fc loop 1 */
    u8   fcLoopStateRsvd;
}__attribute__((packed));


/********************************************
 * PARAM IDs in Notify struct
 ********************************************/
#define PARAM_RBLD_RATE                 0x01
    /*--------------------------------------
     * Param val = 
     *      byte 0: new rbld rate 
     *--------------------------------------*/
#define PARAM_CACHE_FLUSH_INTERVAL      0x02
    /*--------------------------------------
     * Param val = 
     *      byte 0: new cache flush interval
     *--------------------------------------*/
#define PARAM_SENSE_ALERT               0x03
    /*--------------------------------------
     * Param val = 
     *      byte 0: last pdrv id causing chkcond
     *--------------------------------------*/
#define PARAM_DRIVE_INSERTED            0x04
    /*--------------------------------------
     * Param val = 
     *      byte 0: last pdrv id inserted
     *--------------------------------------*/
#define PARAM_BATTERY_STATUS            0x05
    /*--------------------------------------
     * Param val = 
     *      byte 0: battery status
     *--------------------------------------*/

/********************************************
 * Ldrv operation cmd in Notify struct
 ********************************************/
#define LDRV_CMD_CHKCONSISTANCY         0x01
#define LDRV_CMD_INITIALIZE             0x02
#define LDRV_CMD_RECONSTRUCTION         0x03

/********************************************
 * Ldrv operation status in Notify struct
 ********************************************/
#define	LDRV_OP_SUCCESS                 0x00
#define	LDRV_OP_FAILED                  0x01
#define	LDRV_OP_ABORTED                 0x02
#define	LDRV_OP_CORRECTED               0x03
#define	LDRV_OP_STARTED                 0x04


/********************************************
 * Raid Logical drive states.
 ********************************************/
#define     RDRV_OFFLINE                0
#define     RDRV_DEGRADED               1
#define     RDRV_OPTIMAL                2
#define     RDRV_DELETED                3

/*******************************************
 * Physical drive states.
 *******************************************/
#define     PDRV_UNCNF                  0
#define     PDRV_ONLINE                 3
#define     PDRV_FAILED                 4
#define     PDRV_RBLD                   5
/* #define     PDRV_HOTSPARE               6 */

/*******************************************
 * Formal val in Notify struct
 *******************************************/
#define PDRV_FMT_START                  0x01
#define PDRV_FMT_OVER                   0x02

/********************************************
 * FC Loop State in Notify Struct
 ********************************************/
#define ENQ_FCLOOP_FAILED               0
#define ENQ_FCLOOP_ACTIVE               1
#define ENQ_FCLOOP_TRANSIENT            2

/********************************************
 * ENQUIRY3 Strucure
 ********************************************/
/* 
 * Utilities declare this strcture size as 1024 bytes. So more fields can
 * be added in future.
 */
struct MegaRAID_Enquiry3
{
   u32   dataSize; /* current size in bytes (not including resvd) */

   struct MegaRAID_Notify   notify;

   u8   notifyRsvd[MAX_NOTIFY_SIZE - CUR_NOTIFY_SIZE];

   u8   rbldRate;     /* Rebuild rate (0% - 100%) */
   u8   cacheFlushInterval; /* In terms of Seconds */
   u8   senseAlert;
   u8   driveInsertedCount; /* drive insertion count */

   u8   batteryStatus;
   u8   numLDrv;              /* No. of Log Drives configured */
   u8   reconState[FC_MAX_LOGICAL_DRIVES/8]; /* State of reconstruct */
   u16  lDrvOpStatus[FC_MAX_LOGICAL_DRIVES/8]; /* log. Drv Status */

   u32   lDrvSize[FC_MAX_LOGICAL_DRIVES];  /* Size of each log. Drv */
   u8   lDrvProp[FC_MAX_LOGICAL_DRIVES];
   u8   lDrvState[FC_MAX_LOGICAL_DRIVES]; /* State of Logical Drives */
   u8   pDrvState[FC_MAX_PHYSICAL_DEVICES];  /* State of Phys. Drvs. */
   u16  physDrvFormat[FC_MAX_PHYSICAL_DEVICES/16];

   u8   targXfer[80];               /* phys device transfer rate */
   u8   pad1k[263];          /* 761 + 263reserved = 1024 bytes total size */
}__attribute__((packed));
typedef struct MegaRAID_Enquiry3 mega_Enquiry3;

/* Structures */
typedef struct _mega_ADP_INFO {
    u8 MaxConcCmds;
    u8 RbldRate;
    u8 MaxTargPerChan;
    u8 ChanPresent;
    u8 FwVer[4];
    u16 AgeOfFlash;
    u8 ChipSetValue;
    u8 DramSize;
    u8 CacheFlushInterval;
    u8 BiosVer[4];
    u8 resvd[7];
} mega_ADP_INFO;

typedef struct _mega_LDRV_INFO {
    u8 NumLDrv;
    u8 resvd[3];
    u32 LDrvSize[MAX_LOGICAL_DRIVES];
    u8 LDrvProp[MAX_LOGICAL_DRIVES];
    u8 LDrvState[MAX_LOGICAL_DRIVES];
} mega_LDRV_INFO;

typedef struct _mega_PDRV_INFO {
    u8 PDrvState[MAX_PHYSICAL_DRIVES];
    u8 resvd;
} mega_PDRV_INFO;

// RAID inquiry: Mailbox command 0x5
typedef struct _mega_RAIDINQ {
    mega_ADP_INFO AdpInfo;
    mega_LDRV_INFO LogdrvInfo;
    mega_PDRV_INFO PhysdrvInfo;
} mega_RAIDINQ;

// Passthrough command: Mailbox command 0x3
typedef struct mega_passthru {
    u8 timeout:3;		/* 0=6sec/1=60sec/2=10min/3=3hrs */
    u8 ars:1;
    u8 reserved:3;
    u8 islogical:1;
    u8 logdrv;		/* if islogical == 1 */
    u8 channel;		/* if islogical == 0 */
    u8 target;		/* if islogical == 0 */
    u8 queuetag;		/* unused */
    u8 queueaction;		/* unused */
    u8 cdb[MAX_CDB_LEN];
    u8 cdblen;
    u8 reqsenselen;
    u8 reqsensearea[MAX_REQ_SENSE_LEN];
    u8 numsgelements;
    u8 scsistatus;
    u32 dataxferaddr;
    u32 dataxferlen;
} mega_passthru;

struct _mega_mailbox {
    /* 0x0 */ u8 cmd;
    /* 0x1 */ u8 cmdid;
    /* 0x2 */ u16 numsectors;
    /* 0x4 */ u32 lba;
    /* 0x8 */ u32 xferaddr;
    /* 0xC */ u8 logdrv;
    /* 0xD */ u8 numsgelements;
    /* 0xE */ u8 resvd;
    /* 0xF */ u8 busy;
    /* 0x10 */ u8 numstatus;
    /* 0x11 */ u8 status;
    /* 0x12 */ u8 completed[46];
    u8 mraid_poll;
    u8 mraid_ack;
    u8 pad[16]; /* for alignment purposes */
}__attribute__((packed));
typedef struct _mega_mailbox mega_mailbox;

typedef struct {
    u32 xferSegment;      /* for 64-bit controllers */
    mega_mailbox mailbox;
} mega_mailbox64;

typedef struct _mega_ioctl_mbox {
    /* 0x0 */ u8 cmd;
    /* 0x1 */ u8 cmdid;
    /* 0x2 */ u8 channel;
    /* 0x3 */ u8 param;
    /* 0x4 */ u8 pad[4];
    /* 0x8 */ u32 xferaddr;
    /* 0xC */ u8 logdrv;
    /* 0xD */ u8 numsgelements;
    /* 0xE */ u8 resvd;
    /* 0xF */ u8 busy;
    /* 0x10 */ u8 numstatus;
    /* 0x11 */ u8 status;
    /* 0x12 */ u8 completed[46];
    u8 mraid_poll;
    u8 mraid_ack;
    u8 malign[16];
} mega_ioctl_mbox;

typedef struct _mega_sglist {
    u32 address;
    u32 length;
} mega_sglist;

/* Queued command data */
typedef struct _mega_scb mega_scb;

struct _mega_scb {
    int            idx;
    u32            state;
    u32            isrcount;
    u8         mboxData[16];
    mega_passthru  pthru;
    Scsi_Cmnd     *SCpnt;
    mega_sglist   *sgList;
    char          *kern_area;  /* Only used for large ioctl xfers */
    struct wait_queue  *ioctl_wait;
    struct semaphore   sem;
    mega_scb      *next;
};

/* Per-controller data */
typedef struct _mega_host_config {
    u8 numldrv;
    u32 flag;
    u32 base;
 
    mega_scb *qFreeH;
    mega_scb *qFreeT;
    mega_scb *qPendingH;
    mega_scb *qPendingT;
    
    Scsi_Cmnd *qCompletedH;
    Scsi_Cmnd *qCompletedT;
    u32 qFcnt;
    u32 qPcnt;
    u32 qCcnt;

    u32 nReads[FC_MAX_LOGICAL_DRIVES];
    u32 nWrites[FC_MAX_LOGICAL_DRIVES];

    /* Host adapter parameters */
    u8 fwVer[7];
    u8 biosVer[7];

    struct Scsi_Host *host;

    volatile mega_mailbox64 *mbox64;  /* ptr to beginning of 64-bit mailbox */
    volatile mega_mailbox *mbox;     /* ptr to beginning of standard mailbox */
    volatile mega_mailbox64 mailbox64;
#if 0
    volatile union {
         u8            generic_buffer[2 * 1024L];
         mega_RAIDINQ  adapterInfoData;
         mega_Enquiry3 enquiry3Data;
    }mega_buffer;
#else
    volatile u8 mega_buffer[2*1024L];
#endif
    volatile megaRaidProductInfo productInfo;

    u8 max_cmds;
    mega_scb scbList[MAX_COMMANDS];
} mega_host_config;

const char *megaraid_info(struct Scsi_Host *);
int megaraid_detect(Scsi_Host_Template *);
int megaraid_release(struct Scsi_Host *);
int megaraid_command(Scsi_Cmnd *);
int megaraid_abort(Scsi_Cmnd *);
int megaraid_reset(Scsi_Cmnd *, unsigned int);
int megaraid_queue(Scsi_Cmnd *, void (*done) (Scsi_Cmnd *));
int megaraid_biosparam(Disk *, kdev_t, int *);
int megaraid_proc_info(char *buffer, char **start, off_t offset,
		       int length, int hostno, int inout);

#endif