Subversion Repositories or1k

#ifndef __MEGARAID_H__

#define __MEGARAID_H__

#include <linux/version.h>

#include <linux/spinlock.h>

#define MEGARAID_VERSION        \

        "v2.10.1 (Release Date: Wed Dec  3 15:34:42 EST 2003)\n"

/*

 * Driver features - change the values to enable or disable features in the

 * driver.

 */

/*

 * Comand coalescing - This feature allows the driver to be able to combine

 * two or more commands and issue as one command in order to boost I/O

 * performance. Useful if the nature of the I/O is sequential. It is not very

 * useful for random natured I/Os.

 */

#define MEGA_HAVE_COALESCING    0

/*

 * Clustering support - Set this flag if you are planning to use the

 * clustering services provided by the megaraid controllers and planning to

 * setup a cluster

 */

#define MEGA_HAVE_CLUSTERING    1

/*

 * Driver statistics - Set this flag if you are interested in statics about

 * number of I/O completed on each logical drive and how many interrupts

 * generated. If enabled, this information is available through /proc

 * interface and through the private ioctl. Setting this flag has a

 * performance penalty.

 */

#define MEGA_HAVE_STATS         0

/*

 * Enhanced /proc interface - This feature will allow you to have a more

 * detailed /proc interface for megaraid driver. E.g., a real time update of

 * the status of the logical drives, battery status, physical drives etc.

 */

#define MEGA_HAVE_ENH_PROC      1

#define MAX_DEV_TYPE    32

#ifndef PCI_VENDOR_ID_LSI_LOGIC

#define PCI_VENDOR_ID_LSI_LOGIC         0x1000

#endif

#ifndef PCI_VENDOR_ID_AMI

#define PCI_VENDOR_ID_AMI               0x101E

#endif

#ifndef PCI_VENDOR_ID_DELL

#define PCI_VENDOR_ID_DELL              0x1028

#endif

#ifndef PCI_VENDOR_ID_INTEL

#define PCI_VENDOR_ID_INTEL             0x8086

#endif

#ifndef PCI_DEVICE_ID_AMI_MEGARAID

#define PCI_DEVICE_ID_AMI_MEGARAID      0x9010

#endif

#ifndef PCI_DEVICE_ID_AMI_MEGARAID2

#define PCI_DEVICE_ID_AMI_MEGARAID2     0x9060

#endif

#ifndef PCI_DEVICE_ID_AMI_MEGARAID3

#define PCI_DEVICE_ID_AMI_MEGARAID3     0x1960

#endif

#define PCI_DEVICE_ID_DISCOVERY         0x000E

#define PCI_DEVICE_ID_PERC4_DI          0x000F

#define PCI_DEVICE_ID_PERC4_QC_VERDE    0x0407

#define PCI_DEVICE_ID_PERC4E_SI_DI      0x0013

#define PCI_DEVICE_ID_PERC4E_DC_SC      0x0408

#define PCI_DEVICE_ID_LSI_SATA_PCIX     0x0409

/* Sub-System Vendor IDs */

#define AMI_SUBSYS_VID                  0x101E

#define DELL_SUBSYS_VID                 0x1028

#define HP_SUBSYS_VID                   0x103C

#define LSI_SUBSYS_VID                  0x1000

#define INTEL_SUBSYS_VID                0x8086

#define HBA_SIGNATURE                   0x3344

#define HBA_SIGNATURE_471               0xCCCC

#define HBA_SIGNATURE_64BIT             0x0299

#define MBOX_BUSY_WAIT                  10      /* wait for up to 10 usec for

                                                   mailbox to be free */

#define DEFAULT_INITIATOR_ID    7

#define MAX_SGLIST              64      /* max supported in f/w */

#define MIN_SGLIST              26      /* guaranteed to support these many */

#define MAX_COMMANDS            126

#define CMDID_INT_CMDS          MAX_COMMANDS+1  /* make sure CMDID_INT_CMDS

                                                is less than max commands

                                                supported by any f/w */

#define MAX_CDB_LEN             10

#define MAX_EXT_CDB_LEN         16      /* we support cdb length up to 16 */

#define DEF_CMD_PER_LUN         63

#define MAX_CMD_PER_LUN         MAX_COMMANDS

#define MAX_FIRMWARE_STATUS     46

#define MAX_XFER_PER_CMD        (64*1024)

#define MAX_SECTORS_PER_IO      128

#define MAX_LOGICAL_DRIVES_40LD         40

#define FC_MAX_PHYSICAL_DEVICES         256

#define MAX_LOGICAL_DRIVES_8LD          8

#define MAX_CHANNELS                    5

#define MAX_TARGET                      15

#define MAX_PHYSICAL_DRIVES             MAX_CHANNELS*MAX_TARGET

#define MAX_ROW_SIZE_40LD               32

#define MAX_ROW_SIZE_8LD                8

#define MAX_SPAN_DEPTH                  8

#define NVIRT_CHAN              4       /* # of virtual channels to represent

                                           up to 60 logical drives */

#define MEGARAID                                                \

{                                                               \

        .name =                         "MegaRAID",             \

        .proc_name =                    "megaraid",             \

        .detect =                       megaraid_detect,        \

        .release =                      megaraid_release,       \

        .info =                         megaraid_info,          \

        .command =                      megaraid_command,       \

        .queuecommand =                 megaraid_queue,         \

        .bios_param =                   megaraid_biosparam,     \

        .max_sectors =                  MAX_SECTORS_PER_IO,     \

        .can_queue =                    MAX_COMMANDS,           \

        .this_id =                      DEFAULT_INITIATOR_ID,   \

        .sg_tablesize =                 MAX_SGLIST,             \

        .cmd_per_lun =                  DEF_CMD_PER_LUN,        \

        .present =                      0,                       \

        .unchecked_isa_dma =            0,                       \

        .use_clustering =               ENABLE_CLUSTERING,      \

        .use_new_eh_code =              1,                      \

        .eh_abort_handler =             megaraid_abort,         \

        .eh_device_reset_handler =      megaraid_reset,         \

        .eh_bus_reset_handler =         megaraid_reset,         \

        .eh_host_reset_handler =        megaraid_reset,         \

        .highmem_io =                   1                       \

}

typedef struct {

        /* 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 */ volatile u8 busy;

        /* 0x10 */ volatile u8 numstatus;

        /* 0x11 */ volatile u8 status;

        /* 0x12 */ volatile u8 completed[MAX_FIRMWARE_STATUS];

        volatile u8 poll;

        volatile u8 ack;

} __attribute__ ((packed)) mbox_t;

typedef struct {

        u32 xfer_segment_lo;

        u32 xfer_segment_hi;

        mbox_t mbox;

} __attribute__ ((packed)) mbox64_t;

/*

 * Passthru definitions

 */

#define MAX_REQ_SENSE_LEN       0x20

typedef struct {

        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;

} __attribute__ ((packed)) mega_passthru;

/*

 * Extended passthru: support CDB > 10 bytes

 */

typedef struct {

        u8 timeout:3;           /* 0=6sec/1=60sec/2=10min/3=3hrs */

        u8 ars:1;

        u8 rsvd1:1;

        u8 cd_rom:1;

        u8 rsvd2:1;

        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 cdblen;

        u8 rsvd3;

        u8 cdb[MAX_EXT_CDB_LEN];

        u8 numsgelements;

        u8 status;

        u8 reqsenselen;

        u8 reqsensearea[MAX_REQ_SENSE_LEN];

        u8 rsvd4;

        u32 dataxferaddr;

        u32 dataxferlen;

} __attribute__ ((packed)) mega_ext_passthru;

typedef struct {

        u64 address;

        u32 length;

} __attribute__ ((packed)) mega_sgl64;

typedef struct {

        u32 address;

        u32 length;

} __attribute__ ((packed)) mega_sglist;

/* Queued command data */

typedef struct {

        int     idx;

        u32     state;

        struct list_head        list;

        u8      raw_mbox[66];

        u32     dma_type;

        u32     dma_direction;

        Scsi_Cmnd       *cmd;

        dma_addr_t      dma_h_bulkdata;

        dma_addr_t      dma_h_sgdata;

        mega_sglist     *sgl;

        mega_sgl64      *sgl64;

        dma_addr_t      sgl_dma_addr;

        mega_passthru           *pthru;

        dma_addr_t              pthru_dma_addr;

        mega_ext_passthru       *epthru;

        dma_addr_t              epthru_dma_addr;

} scb_t;

/*

 * Flags to follow the scb as it transitions between various stages

 */

#define SCB_FREE        0x0000  /* on the free list */

#define SCB_ACTIVE      0x0001  /* off the free list */

#define SCB_PENDQ       0x0002  /* on the pending queue */

#define SCB_ISSUED      0x0004  /* issued - owner f/w */

#define SCB_ABORT       0x0008  /* Got an abort for this one */

#define SCB_RESET       0x0010  /* Got a reset for this one */

/*

 * Utilities declare this strcture size as 1024 bytes. So more fields can

 * be added in future.

 */

typedef struct {

        u32     data_size; /* current size in bytes (not including resvd) */

        u32     config_signature;

                /* Current value is 0x00282008

                 * 0x28=MAX_LOGICAL_DRIVES,

                 * 0x20=Number of stripes and

                 * 0x08=Number of spans */

        u8      fw_version[16];         /* printable ASCI string */

        u8      bios_version[16];       /* printable ASCI string */

        u8      product_name[80];       /* printable ASCI string */

        u8      max_commands;           /* Max. concurrent commands supported */

        u8      nchannels;              /* Number of SCSI Channels detected */

        u8      fc_loop_present;        /* Number of Fibre Loops detected */

        u8      mem_type;               /* EDO, FPM, SDRAM etc */

        u32     signature;

        u16     dram_size;              /* In terms of MB */

        u16     subsysid;

        u16     subsysvid;

        u8      notify_counters;

        u8      pad1k[889];             /* 135 + 889 resvd = 1024 total size */

} __attribute__ ((packed)) mega_product_info;

struct notify {

        u32 global_counter;     /* Any change increments this counter */

        u8 param_counter;       /* Indicates any params changed  */

        u8 param_id;            /* Param modified - defined below */

        u16 param_val;          /* New val of last param modified */

        u8 write_config_counter;        /* write config occurred */

        u8 write_config_rsvd[3];

        u8 ldrv_op_counter;     /* Indicates ldrv op started/completed */

        u8 ldrv_opid;           /* ldrv num */

        u8 ldrv_opcmd;          /* ldrv operation - defined below */

        u8 ldrv_opstatus;       /* status of the operation */

        u8 ldrv_state_counter;  /* Indicates change of ldrv state */

        u8 ldrv_state_id;               /* ldrv num */

        u8 ldrv_state_new;      /* New state */

        u8 ldrv_state_old;      /* old state */

        u8 pdrv_state_counter;  /* Indicates change of ldrv state */

        u8 pdrv_state_id;               /* pdrv id */

        u8 pdrv_state_new;      /* New state */

        u8 pdrv_state_old;      /* old state */

        u8 pdrv_fmt_counter;    /* Indicates pdrv format started/over */

        u8 pdrv_fmt_id;         /* pdrv id */

        u8 pdrv_fmt_val;                /* format started/over */

        u8 pdrv_fmt_rsvd;

        u8 targ_xfer_counter;   /* Indicates SCSI-2 Xfer rate change */

        u8 targ_xfer_id;        /* pdrv Id  */

        u8 targ_xfer_val;               /* new Xfer params of last pdrv */

        u8 targ_xfer_rsvd;

        u8 fcloop_id_chg_counter;       /* Indicates loopid changed */

        u8 fcloopid_pdrvid;             /* pdrv id */

        u8 fcloop_id0;                  /* loopid on fc loop 0 */

        u8 fcloop_id1;                  /* loopid on fc loop 1 */

        u8 fcloop_state_counter;        /* Indicates loop state changed */

        u8 fcloop_state0;               /* state of fc loop 0 */

        u8 fcloop_state1;               /* state of fc loop 1 */

        u8 fcloop_state_rsvd;

} __attribute__ ((packed));

#define MAX_NOTIFY_SIZE     0x80

#define CUR_NOTIFY_SIZE     sizeof(struct notify)

typedef struct {

        u32     data_size; /* current size in bytes (not including resvd) */

        struct notify notify;

        u8      notify_rsvd[MAX_NOTIFY_SIZE - CUR_NOTIFY_SIZE];

        u8      rebuild_rate;           /* Rebuild rate (0% - 100%) */

        u8      cache_flush_interval;   /* In terms of Seconds */

        u8      sense_alert;

        u8      drive_insert_count;     /* drive insertion count */

        u8      battery_status;

        u8      num_ldrv;               /* No. of Log Drives configured */

        u8      recon_state[MAX_LOGICAL_DRIVES_40LD / 8];       /* State of

                                                           reconstruct */

        u16     ldrv_op_status[MAX_LOGICAL_DRIVES_40LD / 8]; /* logdrv

                                                                 Status */

        u32     ldrv_size[MAX_LOGICAL_DRIVES_40LD];/* Size of each log drv */

        u8      ldrv_prop[MAX_LOGICAL_DRIVES_40LD];

        u8      ldrv_state[MAX_LOGICAL_DRIVES_40LD];/* State of log drives */

        u8      pdrv_state[FC_MAX_PHYSICAL_DEVICES];/* State of phys drvs. */

        u16     pdrv_format[FC_MAX_PHYSICAL_DEVICES / 16];

        u8      targ_xfer[80];  /* phys device transfer rate */

        u8      pad1k[263];     /* 761 + 263reserved = 1024 bytes total size */

} __attribute__ ((packed)) mega_inquiry3;

/* Structures */

typedef struct {

        u8      max_commands;   /* Max concurrent commands supported */

        u8      rebuild_rate;   /* Rebuild rate - 0% thru 100% */

        u8      max_targ_per_chan;      /* Max targ per channel */

        u8      nchannels;      /* Number of channels on HBA */

        u8      fw_version[4];  /* Firmware version */

        u16     age_of_flash;   /* Number of times FW has been flashed */

        u8      chip_set_value; /* Contents of 0xC0000832 */

        u8      dram_size;      /* In MB */

        u8      cache_flush_interval;   /* in seconds */

        u8      bios_version[4];

        u8      board_type;

        u8      sense_alert;

        u8      write_config_count;     /* Increase with every configuration

                                           change */

        u8      drive_inserted_count;   /* Increase with every drive inserted

                                         */

        u8      inserted_drive; /* Channel:Id of inserted drive */

        u8      battery_status; /*

                                 * BIT 0: battery module missing

                                 * BIT 1: VBAD

                                 * BIT 2: temprature high

                                 * BIT 3: battery pack missing

                                 * BIT 4,5:

                                 *   00 - charge complete

                                 *   01 - fast charge in progress

                                 *   10 - fast charge fail

                                 *   11 - undefined

                                 * Bit 6: counter > 1000

                                 * Bit 7: Undefined

                                 */

        u8      dec_fault_bus_info;

} __attribute__ ((packed)) mega_adp_info;

typedef struct {

        u8      num_ldrv;       /* Number of logical drives configured */

        u8      rsvd[3];

        u32     ldrv_size[MAX_LOGICAL_DRIVES_8LD];

        u8      ldrv_prop[MAX_LOGICAL_DRIVES_8LD];

        u8      ldrv_state[MAX_LOGICAL_DRIVES_8LD];

} __attribute__ ((packed)) mega_ldrv_info;

typedef struct {

        u8      pdrv_state[MAX_PHYSICAL_DRIVES];

        u8      rsvd;

} __attribute__ ((packed)) mega_pdrv_info;

/* RAID inquiry: Mailbox command 0x05*/

typedef struct {

        mega_adp_info   adapter_info;

        mega_ldrv_info  logdrv_info;

        mega_pdrv_info  pdrv_info;

} __attribute__ ((packed)) mraid_inquiry;

/* RAID extended inquiry: Mailbox command 0x04*/

typedef struct {

        mraid_inquiry   raid_inq;

        u16     phys_drv_format[MAX_CHANNELS];

        u8      stack_attn;

        u8      modem_status;

        u8      rsvd[2];

} __attribute__ ((packed)) mraid_ext_inquiry;

typedef struct {

        u8      channel;

        u8      target;

}__attribute__ ((packed)) adp_device;

typedef struct {

        u32             start_blk;      /* starting block */

        u32             num_blks;       /* # of blocks */

        adp_device      device[MAX_ROW_SIZE_40LD];

}__attribute__ ((packed)) adp_span_40ld;

typedef struct {

        u32             start_blk;      /* starting block */

        u32             num_blks;       /* # of blocks */

        adp_device      device[MAX_ROW_SIZE_8LD];

}__attribute__ ((packed)) adp_span_8ld;

typedef struct {

        u8      span_depth;     /* Total # of spans */

        u8      level;          /* RAID level */

        u8      read_ahead;     /* read ahead, no read ahead, adaptive read

                                   ahead */

        u8      stripe_sz;      /* Encoded stripe size */

        u8      status;         /* Status of the logical drive */

        u8      write_mode;     /* write mode, write_through/write_back */

        u8      direct_io;      /* direct io or through cache */

        u8      row_size;       /* Number of stripes in a row */

} __attribute__ ((packed)) logdrv_param;

typedef struct {

        logdrv_param    lparam;

        adp_span_40ld   span[MAX_SPAN_DEPTH];

}__attribute__ ((packed)) logdrv_40ld;

typedef struct {

        logdrv_param    lparam;

        adp_span_8ld    span[MAX_SPAN_DEPTH];

}__attribute__ ((packed)) logdrv_8ld;

typedef struct {

        u8      type;           /* Type of the device */

        u8      cur_status;     /* current status of the device */

        u8      tag_depth;      /* Level of tagging */

        u8      sync_neg;       /* sync negotiation - ENABLE or DISBALE */

        u32     size;           /* configurable size in terms of 512 byte

                                   blocks */

}__attribute__ ((packed)) phys_drv;

typedef struct {

        u8              nlog_drives;            /* number of logical drives */

        u8              resvd[3];

        logdrv_40ld     ldrv[MAX_LOGICAL_DRIVES_40LD];

        phys_drv        pdrv[MAX_PHYSICAL_DRIVES];

}__attribute__ ((packed)) disk_array_40ld;

typedef struct {

        u8              nlog_drives;    /* number of logical drives */

        u8              resvd[3];

        logdrv_8ld      ldrv[MAX_LOGICAL_DRIVES_8LD];

        phys_drv        pdrv[MAX_PHYSICAL_DRIVES];

}__attribute__ ((packed)) disk_array_8ld;

/*

 *    FW Definitions & Data Structures for 8LD 4-Span and 8-Span Controllers

 */

#define MAX_STRIPES     8

#define SPAN4_DEPTH     4

#define SPAN8_DEPTH     8

#define MAX_PHYDRVS     5 * 16  /* 5 Channels * 16 Targets */

typedef struct  {

        unsigned char   channel;

        unsigned char   target;

}__attribute__ ((packed)) device_t;

typedef struct {

        unsigned long   start_blk;

        unsigned long   total_blks;

        device_t        device[ MAX_STRIPES ];

}__attribute__ ((packed)) span_t;

typedef struct {

        unsigned char   type;

        unsigned char   curr_status;

        unsigned char   tag_depth;

        unsigned char   resvd1;

        unsigned long   size;

}__attribute__ ((packed)) phydrv_t;

typedef struct {

        unsigned char   span_depth;

        unsigned char   raid;

        unsigned char   read_ahead;     /* 0=No rdahead,1=RDAHEAD,2=adaptive */

        unsigned char   stripe_sz;

        unsigned char   status;

        unsigned char   write_policy;   /* 0=wrthru,1=wrbak */

        unsigned char   direct_io;      /* 1=directio,0=cached */

        unsigned char   no_stripes;

        span_t          span[ SPAN4_DEPTH ];

}__attribute__ ((packed)) ld_span4_t;

typedef struct {

        unsigned char   span_depth;

        unsigned char   raid;

        unsigned char   read_ahead;     /* 0=No rdahead,1=RDAHEAD,2=adaptive */

        unsigned char   stripe_sz;

        unsigned char   status;

        unsigned char   write_policy;   /* 0=wrthru,1=wrbak */

        unsigned char   direct_io;      /* 1=directio,0=cached */

        unsigned char   no_stripes;

        span_t          span[ SPAN8_DEPTH ];

}__attribute__ ((packed)) ld_span8_t;

typedef struct {

        unsigned char   no_log_drives;

        unsigned char   pad[3];

        ld_span4_t      log_drv[ MAX_LOGICAL_DRIVES_8LD ];

        phydrv_t        phys_drv[ MAX_PHYDRVS ];

}__attribute__ ((packed)) diskarray_span4_t;

typedef struct {

        unsigned char   no_log_drives;

        unsigned char   pad[3];

        ld_span8_t      log_drv[ MAX_LOGICAL_DRIVES_8LD ];

        phydrv_t        phys_drv[ MAX_PHYDRVS ];

}__attribute__ ((packed)) diskarray_span8_t;

/*

 * User ioctl structure.

 * This structure will be used for Traditional Method ioctl interface

 * commands (0x80),Alternate Buffer Method (0x81) ioctl commands and the

 * Driver ioctls.

 * The Driver ioctl interface handles the commands at the driver level,

 * without being sent to the card.

 */

/* system call imposed limit. Change accordingly */

#define IOCTL_MAX_DATALEN       4096

struct uioctl_t {

        u32 inlen;

        u32 outlen;

        union {

                u8 fca[16];

                struct {

                        u8 opcode;

                        u8 subopcode;

                        u16 adapno;

#if BITS_PER_LONG == 32

                        u8 *buffer;

                        u8 pad[4];

#endif

#if BITS_PER_LONG == 64

                        u8 *buffer;

#endif

                        u32 length;

                } __attribute__ ((packed)) fcs;

        } __attribute__ ((packed)) ui;

        u8 mbox[18];            /* 16 bytes + 2 status bytes */

        mega_passthru pthru;

#if BITS_PER_LONG == 32

        char *data;             /* buffer <= 4096 for 0x80 commands */

        char pad[4];

#endif

#if BITS_PER_LONG == 64

        char *data;

#endif

} __attribute__ ((packed));

/*

 * struct mcontroller is used to pass information about the controllers in the

 * system. Its upto the application how to use the information. We are passing

 * as much info about the cards as possible and useful. Before issuing the

 * call to find information about the cards, the applicaiton needs to issue a

 * ioctl first to find out the number of controllers in the system.

 */

#define MAX_CONTROLLERS 32

struct mcontroller {

        u64 base;

        u8 irq;

        u8 numldrv;

        u8 pcibus;

        u16 pcidev;

        u8 pcifun;

        u16 pciid;

        u16 pcivendor;

        u8 pcislot;

        u32 uid;

};

/*

 * mailbox structure used for internal commands

 */

typedef struct {

        u8      cmd;

        u8      cmdid;

        u8      opcode;

        u8      subopcode;

        u32     lba;

        u32     xferaddr;

        u8      logdrv;

        u8      rsvd[3];

        u8      numstatus;

        u8      status;

} __attribute__ ((packed)) megacmd_t;

/*

 * Defines for Driver IOCTL interface

 */

#define MEGAIOC_MAGIC   'm'

#define MEGAIOC_QNADAP          'm'     /* Query # of adapters */

#define MEGAIOC_QDRVRVER        'e'     /* Query driver version */

#define MEGAIOC_QADAPINFO       'g'     /* Query adapter information */

#define MKADAP(adapno)          (MEGAIOC_MAGIC << 8 | (adapno) )

#define GETADAP(mkadap)         ( (mkadap) ^ MEGAIOC_MAGIC << 8 )

/*

 * Definition for the new ioctl interface (NIT)

 */

/*

 * Vendor specific Group-7 commands

 */

#define VENDOR_SPECIFIC_COMMANDS        0xE0

#define MEGA_INTERNAL_CMD               VENDOR_SPECIFIC_COMMANDS + 0x01

/*

 * The ioctl command. No other command shall be used for this interface

 */

#define USCSICMD        VENDOR_SPECIFIC_COMMANDS

/*

 * Data direction flags

 */

#define UIOC_RD         0x00001

#define UIOC_WR         0x00002

/*

 * ioctl opcodes

 */

#define MBOX_CMD        0x00000 /* DCMD or passthru command */

#define GET_DRIVER_VER  0x10000 /* Get driver version */

#define GET_N_ADAP      0x20000 /* Get number of adapters */

#define GET_ADAP_INFO   0x30000 /* Get information about a adapter */

#define GET_CAP         0x40000 /* Get ioctl capabilities */

#define GET_STATS       0x50000 /* Get statistics, including error info */

/*

 * The ioctl structure.

 * MBOX macro converts a nitioctl_t structure to megacmd_t pointer and

 * MBOX_P macro converts a nitioctl_t pointer to megacmd_t pointer.

 */

typedef struct {

        char            signature[8];   /* Must contain "MEGANIT" */

        u32             opcode;         /* opcode for the command */

        u32             adapno;         /* adapter number */

        union {

                u8      __raw_mbox[18];

                caddr_t __uaddr; /* xferaddr for non-mbox cmds */

        }__ua;

#define uioc_rmbox      __ua.__raw_mbox

#define MBOX(uioc)      ((megacmd_t *)&((uioc).__ua.__raw_mbox[0]))

#define MBOX_P(uioc)    ((megacmd_t *)&((uioc)->__ua.__raw_mbox[0]))

#define uioc_uaddr      __ua.__uaddr

        u32             xferlen;        /* xferlen for DCMD and non-mbox

                                           commands */

        u32             flags;          /* data direction flags */

}nitioctl_t;

/*

 * I/O statistics for some applications like SNMP agent. The caller must

 * provide the number of logical drives for which status should be reported.

 */

typedef struct {

        int     num_ldrv;       /* Number for logical drives for which the

                                   status should be reported. */

        u32     nreads[MAX_LOGICAL_DRIVES_40LD];        /* number of reads for

                                                        each logical drive */

        u32     nreadblocks[MAX_LOGICAL_DRIVES_40LD];   /* number of blocks

                                                        read for each logical

                                                        drive */

        u32     nwrites[MAX_LOGICAL_DRIVES_40LD];       /* number of writes

                                                        for each logical

                                                        drive */

        u32     nwriteblocks[MAX_LOGICAL_DRIVES_40LD];  /* number of blocks

                                                        writes for each

                                                        logical drive */

        u32     rd_errors[MAX_LOGICAL_DRIVES_40LD];     /* number of read

                                                           errors for each

                                                           logical drive */

        u32     wr_errors[MAX_LOGICAL_DRIVES_40LD];     /* number of write

                                                           errors for each

                                                           logical drive */

}megastat_t;

struct private_bios_data {

        u8      geometry:4;     /*

                                 * bits 0-3 - BIOS geometry

                                 * 0x0001 - 1GB

                                 * 0x0010 - 2GB

                                 * 0x1000 - 8GB

                                 * Others values are invalid

                                                         */

        u8      unused:4;       /* bits 4-7 are unused */