/*
 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * Copyright 2005-06 Adaptec, Inc.
 * Copyright (c) 2005-06 Adaptec Inc., Achim Leubner
 * Copyright (c) 2000 Michael Smith
 * Copyright (c) 2000-2001 Scott Long
 * Copyright (c) 2000 BSDi
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *    $FreeBSD: src/sys/dev/aac/aacreg.h,v 1.23 2005/10/14 16:22:45 scottl Exp $
 */

#ifndef __AAC_REGS_H__
#define __AAC_REGS_H__

#ifdef  __cplusplus
extern "C" {
#endif

/* Status bits in the doorbell registers */
#define AAC_DB_SYNC_COMMAND             (1<<0)  /* send/completed synchronous */
                                                /* FIB */
#define AAC_DB_COMMAND_READY            (1<<1)  /* posted one or more */
                                                /* commands */
#define AAC_DB_RESPONSE_READY           (1<<2)  /* one or more commands */
                                                /* complete */
#define AAC_DB_COMMAND_NOT_FULL         (1<<3)  /* command queue not full */
#define AAC_DB_RESPONSE_NOT_FULL        (1<<4)  /* response queue not full */
#define AAC_DB_PRINTF_READY             (1<<5)  /* adapter requests host */
                                                /* printf */
#define AAC_DB_INTR_BITS (AAC_DB_COMMAND_READY | \
        AAC_DB_RESPONSE_READY | AAC_DB_PRINTF_READY)
#define AAC_DB_INTR_NEW                 0x08

/* Status bits in firmware status reg */
#define AAC_SELF_TEST_FAILED            0x00000004
#define AAC_MONITOR_PANIC               0x00000020
#define AAC_KERNEL_UP_AND_RUNNING       0x00000080
#define AAC_KERNEL_PANIC                0x00000100

/* aac registers definitions */
#define AAC_OMR0                0x18    /* outbound message register 0 */
#define AAC_OMR1                0x1c    /* outbound message register 1 */
#define AAC_IDBR                0x20    /* inbound doorbell reg */
#define AAC_ODBR                0x2c    /* outbound doorbell reg */
#define AAC_OIMR                0x34    /* outbound interrupt mask reg */
#define AAC_IRCSR               0x38    /* inbound dual cores reset (SRL) */
#define AAC_IQUE                0x40    /* inbound queue */
#define AAC_OQUE                0x44    /* outbound queue */
#define AAC_RX_MAILBOX          0x50    /* mailbox, size=20bytes, rx */
#define AAC_RX_FWSTATUS         0x6c    /* firmware status, rx */
#define AAC_RKT_MAILBOX         0x1000  /* mailbox, size=20bytes, rkt */
#define AAC_RKT_FWSTATUS        0x101c  /* firmware status, rkt */

/* Synchronous commands to the monitor/kernel. */
#define AAC_BREAKPOINT_REQ      0x04
#define AAC_MONKER_INITSTRUCT   0x05
#define AAC_MONKER_SYNCFIB      0x0c
#define AAC_MONKER_GETKERNVER   0x11
#define AAC_MONKER_GETINFO      0x19
#define AAC_MONKER_GETDRVPROP   0x23
#define AAC_MONKER_GETCOMMPREF  0x26
#define AAC_IOP_RESET           0x1000

/* Sunrise Lake dual core reset */
#define AAC_IRCSR_CORES_RST     3

#define AAC_SECTOR_SIZE         512
#define AAC_NUMBER_OF_HEADS     255
#define AAC_SECTORS_PER_TRACK   63
#define AAC_ROTATION_SPEED      10000
#define AAC_MAX_PFN             0xfffff

#define AAC_ADDITIONAL_LEN      31
#define AAC_ANSI_VER            2
#define AAC_RESP_DATA_FORMAT    2

#define AAC_MAX_LD              64      /* max number of logical disks */
#define AAC_MAX_PD(s)           ((s)->bus_max * (s)->tgt_max)
#define AAC_MAX_DEV(s)          (AAC_MAX_LD + AAC_MAX_PD((s)))
#define AAC_BLK_SIZE            AAC_SECTOR_SIZE
#define AAC_DMA_ALIGN           4
#define AAC_DMA_ALIGN_MASK      (AAC_DMA_ALIGN - 1)

#define AAC_MAX_CONTAINERS      AAC_MAX_LD

/*
 * Minimum memory sizes we need to map to address the adapter. Before
 * we know the actual size to map, minimum memory is used instead.
 */
#define AAC_MAP_SIZE_MIN_RX     4096
#define AAC_MAP_SIZE_MIN_RKT    8192

/*
 * Options supported by the adapter
 */
#define AAC_SUPPORTED_SNAPSHOT                  0x01
#define AAC_SUPPORTED_CLUSTERS                  0x02
#define AAC_SUPPORTED_WRITE_CACHE               0x04
#define AAC_SUPPORTED_64BIT_DATA                0x08
#define AAC_SUPPORTED_HOST_TIME_FIB             0x10
#define AAC_SUPPORTED_RAID50                    0x20
#define AAC_SUPPORTED_4GB_WINDOW                0x40
#define AAC_SUPPORTED_SCSI_UPGRADEABLE          0x80
#define AAC_SUPPORTED_SOFT_ERR_REPORT           0x100
#define AAC_SUPPORTED_NOT_RECONDITION           0x200
#define AAC_SUPPORTED_SGMAP_HOST64              0x400
#define AAC_SUPPORTED_ALARM                     0x800
#define AAC_SUPPORTED_NONDASD                   0x1000
#define AAC_SUPPORTED_SCSI_MANAGED              0x2000
#define AAC_SUPPORTED_RAID_SCSI_MODE            0x4000
#define AAC_SUPPORTED_SUPPLEMENT_ADAPTER_INFO   0x10000
#define AAC_SUPPORTED_NEW_COMM                  0x20000
#define AAC_SUPPORTED_64BIT_ARRAYSIZE           0x40000
#define AAC_SUPPORTED_HEAT_SENSOR               0x80000

/*
 * More options from supplement info - SupportedOptions2
 */
#define AAC_SUPPORTED_MU_RESET                  0x01
#define AAC_SUPPORTED_IGNORE_RESET              0x02
#define AAC_SUPPORTED_POWER_MANAGEMENT          0x04
#define AAC_SUPPORTED_ARCIO_PHYDEV              0x08
/*
 * FeatureBits of RequestSupplementAdapterInfo used in the driver
 */
#define AAC_FEATURE_SUPPORTED_JBOD              0x08000000

#pragma pack(1)

/*
 * FIB (FSA Interface Block) this is the data structure passed between
 * the host and adapter.
 */
struct aac_fib_header {
        uint32_t        XferState;
        uint16_t        Command;
        uint8_t         StructType;
        uint8_t         Flags;
        uint16_t        Size;
        uint16_t        SenderSize;
        uint32_t        SenderFibAddress;
        uint32_t        ReceiverFibAddress;
        uint32_t        SenderData;
        int prev;
        int next;
};

/* FIB completed without error or no data was transferred in the FIB */
#define AAC_SENDERADDR_MASK_FAST_RESPONSE       0x01
/* The received FIB is an AIF */
#define AAC_SENDERADDR_MASK_AIF                 0x02

#define AAC_FIB_SIZE            512 /* size of a fib block in byte */
#define AAC_FIB_DATASIZE        (AAC_FIB_SIZE - sizeof (struct aac_fib_header))

struct aac_fib {
        struct aac_fib_header   Header;
        uint8_t data[AAC_FIB_DATASIZE];
};

/* FIB transfer state */
#define AAC_FIBSTATE_HOSTOWNED          (1<<0)  /* owned by the host */
#define AAC_FIBSTATE_ADAPTEROWNED       (1<<1)  /* owned by the adapter */
#define AAC_FIBSTATE_INITIALISED        (1<<2)  /* has been initialised */
#define AAC_FIBSTATE_EMPTY              (1<<3)  /* is empty now */
#define AAC_FIBSTATE_FROMHOST           (1<<5)  /* sent from the host */
#define AAC_FIBSTATE_FROMADAP           (1<<6)  /* sent from the adapter */
#define AAC_FIBSTATE_REXPECTED          (1<<7)  /* response is expected */
#define AAC_FIBSTATE_NOREXPECTED        (1<<8)  /* no response is expected */
#define AAC_FIBSTATE_DONEADAP           (1<<9)  /* processed by the adapter */
#define AAC_FIBSTATE_DONEHOST           (1<<10) /* processed by the host */
#define AAC_FIBSTATE_NORM               (1<<12) /* normal priority */
#define AAC_FIBSTATE_ASYNC              (1<<13)
#define AAC_FIBSTATE_FAST_RESPONSE      (1<<19) /* fast response capable */

/* FIB types */
#define AAC_FIBTYPE_TFIB                1

/*
 * FIB commands
 */

#define TestCommandResponse             1
#define TestAdapterCommand              2
/* Lowlevel and comm commands */
#define LastTestCommand                 100
#define ReinitHostNormCommandQueue      101
#define ReinitHostHighCommandQueue      102
#define ReinitHostHighRespQueue         103
#define ReinitHostNormRespQueue         104
#define ReinitAdapNormCommandQueue      105
#define ReinitAdapHighCommandQueue      107
#define ReinitAdapHighRespQueue         108
#define ReinitAdapNormRespQueue         109
#define InterfaceShutdown               110
#define DmaCommandFib                   120
#define StartProfile                    121
#define TermProfile                     122
#define SpeedTest                       123
#define TakeABreakPt                    124
#define RequestPerfData                 125
#define SetInterruptDefTimer            126
#define SetInterruptDefCount            127
#define GetInterruptDefStatus           128
#define LastCommCommand                 129
/* Filesystem commands */
#define NuFileSystem                    300
#define UFS                             301
#define HostFileSystem                  302
#define LastFileSystemCommand           303
/* Container commands */
#define ContainerCommand                500
#define ContainerCommand64              501
#define RawIo                           502
/* Cluster commands */
#define ClusterCommand                  550
/* Scsi Port commands (scsi passthrough) */
#define ScsiPortCommand                 600
#define ScsiPortCommandU64              601
/* Misc house keeping and generic adapter initiated commands */
#define AifRequest                      700
#define CheckRevision                   701
#define FsaHostShutdown                 702
#define RequestAdapterInfo              703
#define IsAdapterPaused                 704
#define SendHostTime                    705
#define RequestSupplementAdapterInfo    706
#define LastMiscCommand                 707
#define OnLineDiagnostic                800
#define FduAdapterTest                  801

/*
 * Revision number handling
 */
struct FsaRev {
        union {
                struct {
                        uint8_t dash;
                        uint8_t type;
                        uint8_t minor;
                        uint8_t major;
                } comp;
                uint32_t ul;
        } external;
        uint32_t buildNumber;
};

/*
 * Structures used to respond to a RequestAdapterInfo FIB
 */
struct aac_adapter_info {
        uint32_t        PlatformBase;   /* adapter type */
        uint32_t        CpuArchitecture; /* adapter CPU type */
        uint32_t        CpuVariant;     /* adapter CPU subtype */
        uint32_t        ClockSpeed;     /* adapter CPU clockspeed */
        uint32_t        ExecutionMem;   /* adapter Execution Memory size */
        uint32_t        BufferMem;      /* adapter Data Memory */
        uint32_t        TotalMem;       /* adapter Total Memory */
        struct FsaRev   KernelRevision; /* adapter Kernel Software Revision */
        struct FsaRev   MonitorRevision; /* adapter Monitor Software Revision */
        struct FsaRev   HardwareRevision;
        struct FsaRev   BIOSRevision;   /* adapter BIOS Revision */
        uint32_t        ClusteringEnabled;
        uint32_t        ClusterChannelMask;
        uint64_t        SerialNumber;
        uint32_t        batteryPlatform;
        uint32_t        SupportedOptions; /* supported features */
        uint32_t        OemVariant;
};

/*
 * The following definitions on Supplement Adapter Information
 * come from Adaptec:
 */
struct vpd_info {
        uint8_t         AssemblyPn[8];
        uint8_t         FruPn[8];
        uint8_t         BatteryFruPn[8];
        uint8_t         EcVersionString[8];
        uint8_t         Tsid[12];
};

#define MFG_PCBA_SERIAL_NUMBER_WIDTH    12
#define MFG_WWN_WIDTH                   8

struct aac_supplement_adapter_info {
        /* The assigned Adapter Type Text, extra byte for null termination */
        int8_t          AdapterTypeText[17+1];
        /* Pad for the text above */
        int8_t          Pad[2];
        /* Size in bytes of the memory that is flashed */
        uint32_t        FlashMemoryByteSize;
        /* The assigned IMAGEID_xxx for this adapter */
        uint32_t        FlashImageId;
        /*
         * The maximum number of Phys available on a SATA/SAS
         * Controller, 0 otherwise
         */
        uint32_t        MaxNumberPorts;
        /* Version of expansion area */
        uint32_t        Version;
        uint32_t        FeatureBits;
        uint8_t         SlotNumber;
        uint8_t         ReservedPad0[3];
        uint8_t         BuildDate[12];
        /* The current number of Ports on a SAS controller, 0 otherwise */
        uint32_t        CurrentNumberPorts;

        struct vpd_info VpdInfo;

        /* Firmware Revision (Vmaj.min-dash.) */
        struct FsaRev   FlashFirmwareRevision;
        uint32_t        RaidTypeMorphOptions;
        /* Firmware's boot code Revision (Vmaj.min-dash.) */
        struct FsaRev   FlashFirmwareBootRevision;
        /* PCBA serial no. from th MFG sector */
        uint8_t         MfgPcbaSerialNo[MFG_PCBA_SERIAL_NUMBER_WIDTH];
        /* WWN from the MFG sector */
        uint8_t         MfgWWNName[MFG_WWN_WIDTH];
        uint32_t        SupportedOptions2;      /* more supported features */
        uint32_t        ExpansionFlag;  /* 1 - following fields are valid */
        uint32_t        FeatureBits3;
        uint32_t        SupportedPerformanceMode;
        /* Growth Area for future expansion */
        uint32_t        ReservedGrowth[80];
};

/* Container creation data */
struct aac_container_creation {
        uint8_t         ViaBuildNumber;
        uint8_t         MicroSecond;
        uint8_t         Via;            /* 1 = FSU, 2 = API, etc */
        uint8_t         Years;          /* Since1900 */
        uint32_t        Month:4;        /* 1-12 */
        uint32_t        Day:6;          /* 1-32 */
        uint32_t        Hour:6;         /* 0-23 */
        uint32_t        Minute:6;       /* 0-59 */
        uint32_t        Second:6;       /* 0-59 */
        uint64_t        ViaAdapterSerialNumber;
};

struct aac_mntobj {
        uint32_t                ObjectId;
        char                    FileSystemName[16];
        struct aac_container_creation   CreateInfo;
        uint32_t                Capacity;
        uint32_t                VolType;
        uint32_t                ObjType;
        uint32_t                ContentState;
        union {
                uint32_t        pad[8];
        } ObjExtension;
        uint32_t                AlterEgoId;

        uint32_t                CapacityHigh; /* 64-bit LBA */
};

struct aac_mntinfo {
        uint32_t        Command;
        uint32_t        MntType;
        uint32_t        MntCount;
};

struct aac_mntinforesp {
        uint32_t                Status;
        uint32_t                MntType;
        uint32_t                MntRespCount;
        struct aac_mntobj       MntObj;
};

/*
 * Structures used to access physical drives
 */
struct aac_bus_info {
        uint32_t        Command;        /* VM_Ioctl */
        uint32_t        ObjType;        /* FT_DRIVE */
        uint32_t        MethodId;       /* 1 = SCSI Layer */
        uint32_t        ObjectId;       /* Handle */
        uint32_t        CtlCmd;         /* GetBusInfo */
};

struct aac_bus_info_response {
        uint32_t        Status;         /* ST_OK */
        uint32_t        ObjType;
        uint32_t        MethodId;       /* unused */
        uint32_t        ObjectId;       /* unused */
        uint32_t        CtlCmd;         /* unused */
        uint32_t        ProbeComplete;
        uint32_t        BusCount;
        uint32_t        TargetsPerBus;
        uint8_t         InitiatorBusId[10];
        uint8_t         BusValid[10];
};

#define CT_FIB_PARAMS                   6
#define MAX_FIB_PARAMS                  10
#define CT_PACKET_SIZE \
        (AAC_FIB_DATASIZE - sizeof (uint32_t) - \
        ((sizeof (uint32_t)) * (MAX_FIB_PARAMS + 1)))

#define CNT_SIZE                        5

/* Container types */
typedef enum {
        CT_NONE = 0,
        CT_VOLUME,
        CT_MIRROR,
        CT_STRIPE,
        CT_RAID5,
        CT_SSRW,
        CT_SSRO,
        CT_MORPH,
        CT_PASSTHRU,
        CT_RAID4,
        CT_RAID10,              /* stripe of mirror */
        CT_RAID00,              /* stripe of stripe */
        CT_VOLUME_OF_MIRRORS,   /* volume of mirror */
        CT_PSEUDO_RAID3,        /* really raid4 */
        CT_RAID50,              /* stripe of raid5 */
        CT_RAID5D,              /* raid5 distributed hot-sparing */
        CT_RAID5D0,
        CT_RAID1E,              /* extended raid1 mirroring */
        CT_RAID6,
        CT_RAID60
} AAC_FSAVolType;

/*
 * Container Configuration Sub-Commands
 */
typedef enum {
        CT_Null = 0,
        CT_GET_SLICE_COUNT,             /* 1 */
        CT_GET_PARTITION_COUNT,         /* 2 */
        CT_GET_PARTITION_INFO,          /* 3 */
        CT_GET_CONTAINER_COUNT,         /* 4 */
        CT_GET_CONTAINER_INFO_OLD,      /* 5 */
        CT_WRITE_MBR,                   /* 6 */
        CT_WRITE_PARTITION,             /* 7 */
        CT_UPDATE_PARTITION,            /* 8 */
        CT_UNLOAD_CONTAINER,            /* 9 */
        CT_CONFIG_SINGLE_PRIMARY,       /* 10 */
        CT_READ_CONFIG_AGE,             /* 11 */
        CT_WRITE_CONFIG_AGE,            /* 12 */
        CT_READ_SERIAL_NUMBER,          /* 13 */
        CT_ZERO_PAR_ENTRY,              /* 14 */
        CT_READ_MBR,                    /* 15 */
        CT_READ_PARTITION,              /* 16 */
        CT_DESTROY_CONTAINER,           /* 17 */
        CT_DESTROY2_CONTAINER,          /* 18 */
        CT_SLICE_SIZE,                  /* 19 */
        CT_CHECK_CONFLICTS,             /* 20 */
        CT_MOVE_CONTAINER,              /* 21 */
        CT_READ_LAST_DRIVE,             /* 22 */
        CT_WRITE_LAST_DRIVE,            /* 23 */
        CT_UNMIRROR,                    /* 24 */
        CT_MIRROR_DELAY,                /* 25 */
        CT_GEN_MIRROR,                  /* 26 */
        CT_GEN_MIRROR2,                 /* 27 */
        CT_TEST_CONTAINER,              /* 28 */
        CT_MOVE2,                       /* 29 */
        CT_SPLIT,                       /* 30 */
        CT_SPLIT2,                      /* 31 */
        CT_SPLIT_BROKEN,                /* 32 */
        CT_SPLIT_BROKEN2,               /* 33 */
        CT_RECONFIG,                    /* 34 */
        CT_BREAK2,                      /* 35 */
        CT_BREAK,                       /* 36 */
        CT_MERGE2,                      /* 37 */
        CT_MERGE,                       /* 38 */
        CT_FORCE_ERROR,                 /* 39 */
        CT_CLEAR_ERROR,                 /* 40 */
        CT_ASSIGN_FAILOVER,             /* 41 */
        CT_CLEAR_FAILOVER,              /* 42 */
        CT_GET_FAILOVER_DATA,           /* 43 */
        CT_VOLUME_ADD,                  /* 44 */
        CT_VOLUME_ADD2,                 /* 45 */
        CT_MIRROR_STATUS,               /* 46 */
        CT_COPY_STATUS,                 /* 47 */
        CT_COPY,                        /* 48 */
        CT_UNLOCK_CONTAINER,            /* 49 */
        CT_LOCK_CONTAINER,              /* 50 */
        CT_MAKE_READ_ONLY,              /* 51 */
        CT_MAKE_READ_WRITE,             /* 52 */
        CT_CLEAN_DEAD,                  /* 53 */
        CT_ABORT_MIRROR_COMMAND,        /* 54 */
        CT_SET,                         /* 55 */
        CT_GET,                         /* 56 */
        CT_GET_NVLOG_ENTRY,             /* 57 */
        CT_GET_DELAY,                   /* 58 */
        CT_ZERO_CONTAINER_SPACE,        /* 59 */
        CT_GET_ZERO_STATUS,             /* 60 */
        CT_SCRUB,                       /* 61 */
        CT_GET_SCRUB_STATUS,            /* 62 */
        CT_GET_SLICE_INFO,              /* 63 */
        CT_GET_SCSI_METHOD,             /* 64 */
        CT_PAUSE_IO,                    /* 65 */
        CT_RELEASE_IO,                  /* 66 */
        CT_SCRUB2,                      /* 67 */
        CT_MCHECK,                      /* 68 */
        CT_CORRUPT,                     /* 69 */
        CT_GET_TASK_COUNT,              /* 70 */
        CT_PROMOTE,                     /* 71 */
        CT_SET_DEAD,                    /* 72 */
        CT_CONTAINER_OPTIONS,           /* 73 */
        CT_GET_NV_PARAM,                /* 74 */
        CT_GET_PARAM,                   /* 75 */
        CT_NV_PARAM_SIZE,               /* 76 */
        CT_COMMON_PARAM_SIZE,           /* 77 */
        CT_PLATFORM_PARAM_SIZE,         /* 78 */
        CT_SET_NV_PARAM,                /* 79 */
        CT_ABORT_SCRUB,                 /* 80 */
        CT_GET_SCRUB_ERROR,             /* 81 */
        CT_LABEL_CONTAINER,             /* 82 */
        CT_CONTINUE_DATA,               /* 83 */
        CT_STOP_DATA,                   /* 84 */
        CT_GET_PARTITION_TABLE,         /* 85 */
        CT_GET_DISK_PARTITIONS,         /* 86 */
        CT_GET_MISC_STATUS,             /* 87 */
        CT_GET_CONTAINER_PERF_INFO,     /* 88 */
        CT_GET_TIME,                    /* 89 */
        CT_READ_DATA,                   /* 90 */
        CT_CTR,                         /* 91 */
        CT_CTL,                         /* 92 */
        CT_DRAINIO,                     /* 93 */
        CT_RELEASEIO,                   /* 94 */
        CT_GET_NVRAM,                   /* 95 */
        CT_GET_MEMORY,                  /* 96 */
        CT_PRINT_CT_LOG,                /* 97 */
        CT_ADD_LEVEL,                   /* 98 */
        CT_NV_ZERO,                     /* 99 */
        CT_READ_SIGNATURE,              /* 100 */
        CT_THROTTLE_ON,                 /* 101 */
        CT_THROTTLE_OFF,                /* 102 */
        CT_GET_THROTTLE_STATS,          /* 103 */
        CT_MAKE_SNAPSHOT,               /* 104 */
        CT_REMOVE_SNAPSHOT,             /* 105 */
        CT_WRITE_USER_FLAGS,            /* 106 */
        CT_READ_USER_FLAGS,             /* 107 */
        CT_MONITOR,                     /* 108 */
        CT_GEN_MORPH,                   /* 109 */
        CT_GET_SNAPSHOT_INFO,           /* 110 */
        CT_CACHE_SET,                   /* 111 */
        CT_CACHE_STAT,                  /* 112 */
        CT_TRACE_START,                 /* 113 */
        CT_TRACE_STOP,                  /* 114 */
        CT_TRACE_ENABLE,                /* 115 */
        CT_TRACE_DISABLE,               /* 116 */
        CT_FORCE_CORE_DUMP,             /* 117 */
        CT_SET_SERIAL_NUMBER,           /* 118 */
        CT_RESET_SERIAL_NUMBER,         /* 119 */
        CT_ENABLE_RAID5,                /* 120 */
        CT_CLEAR_VALID_DUMP_FLAG,       /* 121 */
        CT_GET_MEM_STATS,               /* 122 */
        CT_GET_CORE_SIZE,               /* 123 */
        CT_CREATE_CONTAINER_OLD,        /* 124 */
        CT_STOP_DUMPS,                  /* 125 */
        CT_PANIC_ON_TAKE_A_BREAK,       /* 126 */
        CT_GET_CACHE_STATS,             /* 127 */
        CT_MOVE_PARTITION,              /* 128 */
        CT_FLUSH_CACHE,                 /* 129 */
        CT_READ_NAME,                   /* 130 */
        CT_WRITE_NAME,                  /* 131 */
        CT_TOSS_CACHE,                  /* 132 */
        CT_LOCK_DRAINIO,                /* 133 */
        CT_CONTAINER_OFFLINE,           /* 134 */
        CT_SET_CACHE_SIZE,              /* 135 */
        CT_CLEAN_SHUTDOWN_STATUS,       /* 136 */
        CT_CLEAR_DISKLOG_ON_DISK,       /* 137 */
        CT_CLEAR_ALL_DISKLOG,           /* 138 */
        CT_CACHE_FAVOR,                 /* 139 */
        CT_READ_PASSTHRU_MBR,           /* 140 */
        CT_SCRUB_NOFIX,                 /* 141 */
        CT_SCRUB2_NOFIX,                /* 142 */
        CT_FLUSH,                       /* 143 */
        CT_REBUILD,     /* 144 rma, not really a command, partner to CT_SCRUB */
        CT_FLUSH_CONTAINER,             /* 145 */
        CT_RESTART,                     /* 146 */
        CT_GET_CONFIG_STATUS,           /* 147 */
        CT_TRACE_FLAG,                  /* 148 */
        CT_RESTART_MORPH,               /* 149 */
        CT_GET_TRACE_INFO,              /* 150 */
        CT_GET_TRACE_ITEM,              /* 151 */
        CT_COMMIT_CONFIG,               /* 152 */
        CT_CONTAINER_EXISTS,            /* 153 */
        CT_GET_SLICE_FROM_DEVT,         /* 154 */
        CT_OPEN_READ_WRITE,             /* 155 */
        CT_WRITE_MEMORY_BLOCK,          /* 156 */
        CT_GET_CACHE_PARAMS,            /* 157 */
        CT_CRAZY_CACHE,                 /* 158 */
        CT_GET_PROFILE_STRUCT,          /* 159 */
        CT_SET_IO_TRACE_FLAG,           /* 160 */
        CT_GET_IO_TRACE_STRUCT,         /* 161 */
        CT_CID_TO_64BITS_UID,           /* 162 */
        CT_64BITS_UID_TO_CID,           /* 163 */
        CT_PAR_TO_64BITS_UID,           /* 164 */
        CT_CID_TO_32BITS_UID,           /* 165 */
        CT_32BITS_UID_TO_CID,           /* 166 */
        CT_PAR_TO_32BITS_UID,           /* 167 */
        CT_SET_FAILOVER_OPTION,         /* 168 */
        CT_GET_FAILOVER_OPTION,         /* 169 */
        CT_STRIPE_ADD2,                 /* 170 */
        CT_CREATE_VOLUME_SET,           /* 171 */
        CT_CREATE_STRIPE_SET,           /* 172 */
        /* 173  command and partner to scrub and rebuild task types */
        CT_VERIFY_CONTAINER,
        CT_IS_CONTAINER_DEAD,           /* 174 */
        CT_GET_CONTAINER_OPTION,        /* 175 */
        CT_GET_SNAPSHOT_UNUSED_STRUCT,  /* 176 */
        CT_CLEAR_SNAPSHOT_UNUSED_STRUCT,        /* 177 */
        CT_GET_CONTAINER_INFO,          /* 178 */
        CT_CREATE_CONTAINER,            /* 179 */
        CT_CHANGE_CREATIONINFO,         /* 180 */
        CT_CHECK_CONFLICT_UID,          /* 181 */
        CT_CONTAINER_UID_CHECK,         /* 182 */

        /* 183 :RECmm: 20011220 added to support the Babylon */
        CT_IS_CONTAINER_MEATADATA_STANDARD,
        /* 184 :RECmm: 20011220 array imports */
        CT_IS_SLICE_METADATA_STANDARD,

        /* :BIOS_TEST: */
        /* 185 :RECmm: 20020116 added to support BIOS interface for */
        CT_GET_IMPORT_COUNT,
        /* 186 :RECmm: 20020116 metadata conversion */
        CT_CANCEL_ALL_IMPORTS,
        CT_GET_IMPORT_INFO,             /* 187 :RECmm: 20020116 " */
        CT_IMPORT_ARRAY,                /* 188 :RECmm: 20020116 " */
        CT_GET_LOG_SIZE,                /* 189  */

        /* Not BIOS TEST */
        CT_ALARM_GET_STATE,             /* 190 */
        CT_ALARM_SET_STATE,             /* 191 */
        CT_ALARM_ON_OFF,                /* 192 */

        CT_GET_EE_OEM_ID,               /* 193 */

        CT_GET_PPI_HEADERS,             /* 194  get header fields only */
        CT_GET_PPI_DATA,                /* 195  get all ppitable.data */
        /* 196  get only range of entries specified in c_params */
        CT_GET_PPI_ENTRIES,
        /* 197  remove ppitable bundle specified by uid in c_param0 */
        CT_DELETE_PPI_BUNDLE,

        /* 198  current partition structure (not legacy) */
        CT_GET_PARTITION_TABLE_2,
        CT_GET_PARTITION_INFO_2,
        CT_GET_DISK_PARTITIONS_2,

        CT_QUIESCE_ADAPTER,             /* 201  chill dude */
        CT_CLEAR_PPI_TABLE,             /* 202  clear ppi table */

        CT_SET_DEVICE_CACHE_POLICY,     /* 203 */
        CT_GET_DEVICE_CACHE_POLICY,     /* 204 */

        CT_SET_VERIFY_DELAY,            /* 205 */
        CT_GET_VERIFY_DELAY,            /* 206 */

        /* 207 delete all PPI bundles that have an entry for device at devt */
        CT_DELETE_PPI_BUNDLES_FOR_DEVT,

        CT_READ_SW_SECTOR,              /* 208 */
        CT_WRITE_SW_SECTOR,             /* 209 */

        /* 210 added to support firmware cache sync operations */
        CT_GET_CACHE_SYNC_INFO,
        CT_SET_CACHE_SYNC_MODE,         /* 211 */
        CT_PM_DRIVER_SUPPORT,           /* 212 */
        CT_PM_CONFIGURATION,            /* 213 */

        CT_LAST_COMMAND                 /* last command */
} AAC_CTCommand;

/* General return status */
#define CT_OK                           218

/* CT_PM_DRIVER_SUPPORT parameter */
typedef enum {
        AAC_PM_DRIVERSUP_GET_STATUS = 1,
        AAC_PM_DRIVERSUP_START_UNIT,
        AAC_PM_DRIVERSUP_STOP_UNIT
} AAC_CT_PM_DRIVER_SUPPORT_SUB_COM;

struct aac_fsa_ctm {
        uint32_t        command;
        uint32_t        param[CT_FIB_PARAMS];
        int8_t          data[CT_PACKET_SIZE];
};

struct aac_Container {
        uint32_t                Command;
        struct aac_fsa_ctm      CTCommand;
};

struct aac_fsa_ctr {
        uint32_t        response;
        uint32_t        param[CT_FIB_PARAMS];
        int8_t          data[CT_PACKET_SIZE];
};

struct aac_Container_resp {
        uint32_t                Status;
        struct aac_fsa_ctr      CTResponse;
};

struct aac_cf_status_header {
        uint32_t        action;
        uint16_t        flags;
        int16_t         recordcount;
};

enum aac_cf_action_type {
        CFACT_CONTINUE = 0,             /* Continue without pause */
        CFACT_PAUSE,                    /* Pause, then continue */
        CFACT_ABORT                     /* Abort */
};

enum aac_mpe {
        AACMPE_OK = 0x0,
        AACMPE_GET_CONFIG_STATUS = 0x1,
        AACMPE_CONFIG_STATUS = 0x2,
        AACMPE_COMMIT_CONFIG = 0x3
};

/*
 * CT_PAUSE_IO is immediate minimal runtime command that is used
 * to restart the applications and cache.
 */
struct aac_pause_command {
        uint32_t        Command;
        uint32_t        Type;
        uint32_t        Timeout;
        uint32_t        Min;
        uint32_t        NoRescan;
        uint32_t        Parm3;
        uint32_t        Parm4;
        uint32_t        Count;
};

/*
 * The following two definitions come from Adaptec:
 *
 * Used to flush drive cache for container "cid"
 */
struct aac_synchronize_command {
        uint32_t        Command;        /* VM_ContainerConfig */
        uint32_t        Type;           /* CT_FLUSH_CACHE */
        uint32_t        Cid;
        uint32_t        Parm1;
        uint32_t        Parm2;
        uint32_t        Parm3;
        uint32_t        Parm4;
        uint32_t        Count;
};

struct aac_synchronize_reply {
        uint32_t        Dummy0;
        uint32_t        Dummy1;
        uint32_t        Status;
        uint32_t        Parm1;
        uint32_t        Parm2;
        uint32_t        Parm3;
        uint32_t        Parm4;
        uint32_t        Parm5;
        uint8_t         Data[16];
};

/*
 * Command status values
 */
typedef enum {
        ST_OK = 0,
        ST_PERM = 1,
        ST_NOENT = 2,
        ST_IO = 5,
        ST_NXIO = 6,
        ST_E2BIG = 7,
        ST_ACCES = 13,
        ST_EXIST = 17,
        ST_XDEV = 18,
        ST_NODEV = 19,
        ST_NOTDIR = 20,
        ST_ISDIR = 21,
        ST_INVAL = 22,
        ST_FBIG = 27,
        ST_NOSPC = 28,
        ST_ROFS = 30,
        ST_MLINK = 31,
        ST_WOULDBLOCK = 35,
        ST_NAMETOOLONG = 63,
        ST_NOTEMPTY = 66,
        ST_DQUOT = 69,
        ST_STALE = 70,
        ST_REMOTE = 71,
        ST_BADHANDLE = 10001,
        ST_NOT_SYNC = 10002,
        ST_BAD_COOKIE = 10003,
        ST_NOTSUPP = 10004,
        ST_TOOSMALL = 10005,
        ST_SERVERFAULT = 10006,
        ST_BADTYPE = 10007,
        ST_JUKEBOX = 10008,
        ST_NOTMOUNTED = 10009,
        ST_MAINTMODE = 10010,
        ST_STALEACL = 10011
} AAC_FSAStatus;

/*
 * Object-Server / Volume-Manager Dispatch Classes
 */
typedef enum {
        VM_Null = 0,
        VM_NameServe,
        VM_ContainerConfig,
        VM_Ioctl,
        VM_FilesystemIoctl,
        VM_CloseAll,
        VM_CtBlockRead,
        VM_CtBlockWrite,
        VM_SliceBlockRead,      /* raw access to configured "storage objects" */
        VM_SliceBlockWrite,
        VM_DriveBlockRead,      /* raw access to physical devices */
        VM_DriveBlockWrite,
        VM_EnclosureMgt,        /* enclosure management */
        VM_Unused,              /* used to be diskset management */
        VM_CtBlockVerify,
        VM_CtPerf,              /* performance test */
        VM_CtBlockRead64,
        VM_CtBlockWrite64,
        VM_CtBlockVerify64,
        VM_CtHostRead64,
        VM_CtHostWrite64,
        VM_NameServe64 = 22,
        MAX_VMCOMMAND_NUM       /* used for sizing stats array - leave last */
} AAC_VMCommand;

/*
 * Host-addressable object types
 */
typedef enum {
        FT_REG = 1,     /* regular file */
        FT_DIR,         /* directory */
        FT_BLK,         /* "block" device - reserved */
        FT_CHR,         /* "character special" device - reserved */
        FT_LNK,         /* symbolic link */
        FT_SOCK,        /* socket */
        FT_FIFO,        /* fifo */
        FT_FILESYS,     /* ADAPTEC's "FSA"(tm) filesystem */
        FT_DRIVE,       /* physical disk - addressable in scsi by b/t/l */
        FT_SLICE,       /* virtual disk - raw volume - slice */
        FT_PARTITION,   /* FSA partition - carved out of a slice - building */
                        /* block for containers */
        FT_VOLUME,      /* Container - Volume Set */
        FT_STRIPE,      /* Container - Stripe Set */
        FT_MIRROR,      /* Container - Mirror Set */
        FT_RAID5,       /* Container - Raid 5 Set */
        FT_DATABASE     /* Storage object with "foreign" content manager */
} AAC_FType;

/* Host-side scatter/gather list for 32-bit, 64-bit, raw commands */
struct aac_sg_entry {
        uint32_t        SgAddress;
        uint32_t        SgByteCount;
};

struct aac_sg_entry64 {
        uint64_t        SgAddress;
        uint32_t        SgByteCount;
};

struct aac_sg_entryraw {
        uint32_t        Next;           /* reserved */
        uint32_t        Prev;           /* reserved */
        uint64_t        SgAddress;
        uint32_t        SgByteCount;
        uint32_t        Flags;          /* reserved */
};

struct aac_sg_table {
        uint32_t                SgCount;
        struct aac_sg_entry     SgEntry[1]; /* at least there is one */
                                            /* SUN's CC cannot accept [0] */
};

struct aac_sg_table64 {
        uint32_t                SgCount;
        struct aac_sg_entry64   SgEntry64[1];
};

struct aac_sg_tableraw {
        uint32_t                SgCount;
        struct aac_sg_entryraw  SgEntryRaw[1];
};

/*
 * Block read/write operations.
 * These structures are packed into the 'data' area in the FIB.
 */
struct aac_blockread {
        uint32_t                Command;
        uint32_t                ContainerId;
        uint32_t                BlockNumber;
        uint32_t                ByteCount;
        struct aac_sg_table     SgMap;
};

struct aac_blockread64 {
        uint32_t                Command;
        uint16_t                ContainerId;
        uint16_t                SectorCount;
        uint32_t                BlockNumber;
        uint16_t                Pad;
        uint16_t                Flags;
        struct aac_sg_table64   SgMap64;
};

struct aac_blockread_response {
        uint32_t                Status;
        uint32_t                ByteCount;
};

struct aac_blockwrite {
        uint32_t                Command;
        uint32_t                ContainerId;
        uint32_t                BlockNumber;
        uint32_t                ByteCount;
        uint32_t                Stable;
        struct aac_sg_table     SgMap;
};

struct aac_blockwrite64 {
        uint32_t                Command;
        uint16_t                ContainerId;
        uint16_t                SectorCount;
        uint32_t                BlockNumber;
        uint16_t                Pad;
        uint16_t                Flags;
        struct aac_sg_table64   SgMap64;
};

struct aac_blockwrite_response {
        uint32_t                Status;
        uint32_t                ByteCount;
        uint32_t                Committed;
};

struct aac_raw_io {
        uint64_t                BlockNumber;
        uint32_t                ByteCount;
        uint16_t                ContainerId;
        uint16_t                Flags;          /* 0: W, 1: R */
        uint16_t                BpTotal;        /* reserved */
        uint16_t                BpComplete;     /* reserved */
        struct aac_sg_tableraw  SgMapRaw;
};

/*
 * Container shutdown command.
 */
struct aac_close_command {
        uint32_t                Command;
        uint32_t                ContainerId;
};

/*
 * Container Config Command
 */
struct aac_ctcfg {
        uint32_t                Command;
        uint32_t                cmd;
        uint32_t                param;
};

struct aac_ctcfg_resp {
        uint32_t                Status;
        uint32_t                resp;
        uint32_t                param;
};

/* Write 'stability' options */
#define CSTABLE                 1
#define CUNSTABLE               2

/* Number of FIBs for the controller to send us messages */
#define AAC_ADAPTER_FIBS        8

/* Number of FIBs for the host I/O request */
#define AAC_HOST_FIBS           256

/* Size of buffer for text messages from the controller */
#define AAC_ADAPTER_PRINT_BUFSIZE               256

#define AAC_INIT_STRUCT_REVISION                3
#define AAC_INIT_STRUCT_REVISION_4              4
#define AAC_INIT_STRUCT_MINIPORT_REVISION       1

#define AAC_INIT_FLAGS_NEW_COMM_SUPPORTED       1
#define AAC_INIT_FLAGS_DRIVER_USES_UTC_TIME     0x10
#define AAC_INIT_FLAGS_DRIVER_SUPPORTS_PM       0x20

#define AAC_PAGE_SIZE                           4096
struct aac_adapter_init {
        uint32_t        InitStructRevision;
        uint32_t        MiniPortRevision;
        uint32_t        FilesystemRevision;
        uint32_t        CommHeaderAddress;
        uint32_t        FastIoCommAreaAddress;
        uint32_t        AdapterFibsPhysicalAddress;
        uint32_t        AdapterFibsVirtualAddress;
        uint32_t        AdapterFibsSize;
        uint32_t        AdapterFibAlign;
        uint32_t        PrintfBufferAddress;
        uint32_t        PrintfBufferSize;
        uint32_t        HostPhysMemPages;
        uint32_t        HostElapsedSeconds;
        /* ADAPTER_INIT_STRUCT_REVISION_4 begins here */
        uint32_t        InitFlags;
        uint32_t        MaxIoCommands;
        uint32_t        MaxIoSize;
        uint32_t        MaxFibSize;
};

/* ************AAC QUEUE DEFINES (BELOW)*********** */

#define AAC_QUEUE_ALIGN         16
#define AAC_QUEUE_COUNT         8
#define AAC_PRODUCER_INDEX      0
#define AAC_CONSUMER_INDEX      1

struct aac_queue_entry {
        uint32_t aq_fib_size;   /* FIB size in bytes */
        uint32_t aq_fib_addr;   /* receiver-space address of the FIB */
};

/*
 * Queue names
 *
 * Note that we base these at 0 in order to use them as array indices.
 * Adaptec used base 1 for some unknown reason, and sorted them in a
 * different order.
 */
#define AAC_HOST_NORM_CMD_Q     0
#define AAC_HOST_HIGH_CMD_Q     1
#define AAC_ADAP_NORM_CMD_Q     2
#define AAC_ADAP_HIGH_CMD_Q     3
#define AAC_HOST_NORM_RESP_Q    4
#define AAC_HOST_HIGH_RESP_Q    5
#define AAC_ADAP_NORM_RESP_Q    6
#define AAC_ADAP_HIGH_RESP_Q    7

/*
 * We establish 4 command queues and matching response queues. Queues must
 * be 16-byte aligned, and are sized as follows:
 */
/* command adapter->host, normal priority */
#define AAC_HOST_NORM_CMD_ENTRIES       8
/* command adapter->host, high priority */
#define AAC_HOST_HIGH_CMD_ENTRIES       4
/* command host->adapter, normal priority */
#define AAC_ADAP_NORM_CMD_ENTRIES       512
/* command host->adapter, high priority */
#define AAC_ADAP_HIGH_CMD_ENTRIES       4
/* response, adapter->host, normal priority */
#define AAC_HOST_NORM_RESP_ENTRIES      512
/* response, adapter->host, high priority */
#define AAC_HOST_HIGH_RESP_ENTRIES      4
/* response, host->adapter, normal priority */
#define AAC_ADAP_NORM_RESP_ENTRIES      8
/* response, host->adapter, high priority */
#define AAC_ADAP_HIGH_RESP_ENTRIES      4

#define AAC_TOTALQ_LENGTH       (AAC_HOST_HIGH_CMD_ENTRIES + \
                                AAC_HOST_NORM_CMD_ENTRIES + \
                                AAC_ADAP_HIGH_CMD_ENTRIES + \
                                AAC_ADAP_NORM_CMD_ENTRIES + \
                                AAC_HOST_HIGH_RESP_ENTRIES + \
                                AAC_HOST_NORM_RESP_ENTRIES + \
                                AAC_ADAP_HIGH_RESP_ENTRIES + \
                                AAC_ADAP_NORM_RESP_ENTRIES)

/*
 * Table of queue indices and queues used to communicate with the
 * controller. This structure must be aligned to AAC_QUEUE_ALIGN.
 */
struct aac_queue_table {
        /* queue consumer/producer indexes (layout mandated by adapter) */
        uint32_t qt_qindex[AAC_QUEUE_COUNT][2];

        /* queue entry structures (layout mandated by adapter) */
        struct aac_queue_entry qt_HostNormCmdQueue \
            [AAC_HOST_NORM_CMD_ENTRIES];
        struct aac_queue_entry qt_HostHighCmdQueue \
            [AAC_HOST_HIGH_CMD_ENTRIES];
        struct aac_queue_entry qt_AdapNormCmdQueue \
            [AAC_ADAP_NORM_CMD_ENTRIES];
        struct aac_queue_entry qt_AdapHighCmdQueue \
            [AAC_ADAP_HIGH_CMD_ENTRIES];
        struct aac_queue_entry qt_HostNormRespQueue \
            [AAC_HOST_NORM_RESP_ENTRIES];
        struct aac_queue_entry qt_HostHighRespQueue \
            [AAC_HOST_HIGH_RESP_ENTRIES];
        struct aac_queue_entry qt_AdapNormRespQueue \
            [AAC_ADAP_NORM_RESP_ENTRIES];
        struct aac_queue_entry qt_AdapHighRespQueue \
            [AAC_ADAP_HIGH_RESP_ENTRIES];
};
/* ************AAC QUEUE DEFINES (ABOVE)*********** */

/*
 * NVRAM/Write Cache subsystem battery component states
 */
typedef enum {
        NVBATTSTATUS_NONE = 0,  /* battery has no power or is not present */
        NVBATTSTATUS_LOW,       /* battery is low on power */
        NVBATTSTATUS_OK,        /* battery is okay - normal operation */
                                /* possible only in this state */
        NVBATTSTATUS_RECONDITIONING     /* no battery present */
                                        /* - reconditioning in process */
} AAC_NVBATTSTATUS;

/*
 * Battery transition type
 */
typedef enum {
        NVBATT_TRANSITION_NONE = 0,     /* battery now has no power or is not */
                                        /* present */
        NVBATT_TRANSITION_LOW,  /* battery is now low on power */
        NVBATT_TRANSITION_OK    /* battery is now okay - normal */
                                /* operation possible only in this state */
} AAC_NVBATT_TRANSITION;

/*
 * Data types relating to AIFs
 */

/*
 * Progress Reports
 */
typedef enum {
        AifJobStsSuccess = 1,
        AifJobStsFinished,
        AifJobStsAborted,
        AifJobStsFailed,
        AifJobStsLastReportMarker = 100,        /* All prior mean last report */
        AifJobStsSuspended,
        AifJobStsRunning
} AAC_AifJobStatus;

typedef enum {
        AifJobScsiMin = 1,      /* Minimum value for Scsi operation */
        AifJobScsiZero,         /* SCSI device clear operation */
        AifJobScsiVerify,       /* SCSI device Verify operation NO REPAIR */
        AifJobScsiExercise,     /* SCSI device Exercise operation */
        AifJobScsiVerifyRepair, /* SCSI device Verify operation WITH repair */
        AifJobScsiWritePattern, /* write pattern */
        AifJobScsiMax = 99,     /* Max Scsi value */
        AifJobCtrMin,           /* Min Ctr op value */
        AifJobCtrZero,          /* Container clear operation */
        AifJobCtrCopy,          /* Container copy operation */
        AifJobCtrCreateMirror,  /* Container Create Mirror operation */
        AifJobCtrMergeMirror,   /* Container Merge Mirror operation */
        AifJobCtrScrubMirror,   /* Container Scrub Mirror operation */
        AifJobCtrRebuildRaid5,  /* Container Rebuild Raid5 operation */
        AifJobCtrScrubRaid5,    /* Container Scrub Raid5 operation */
        AifJobCtrMorph,         /* Container morph operation */
        AifJobCtrPartCopy,      /* Container Partition copy operation */
        AifJobCtrRebuildMirror, /* Container Rebuild Mirror operation */
        AifJobCtrCrazyCache,    /* crazy cache */
        AifJobCtrCopyback,      /* Container Copyback operation */
        AifJobCtrCompactRaid5D, /* Container Compaction operation */
        AifJobCtrExpandRaid5D,  /* Container Expansion operation */
        AifJobCtrRebuildRaid6,  /* Container Rebuild Raid6 operation */
        AifJobCtrScrubRaid6,    /* Container Scrub Raid6 operation */
        AifJobCtrSSBackup,      /* Container snapshot backup task */
        AifJobCtrMax = 199,     /* Max Ctr type operation */
        AifJobFsMin,            /* Min Fs type operation */
        AifJobFsCreate,         /* File System Create operation */
        AifJobFsVerify,         /* File System Verify operation */
        AifJobFsExtend,         /* File System Extend operation */
        AifJobFsMax = 299,      /* Max Fs type operation */
        AifJobApiFormatNTFS,    /* Format a drive to NTFS */
        AifJobApiFormatFAT,     /* Format a drive to FAT */
        AifJobApiUpdateSnapshot, /* update the read/write half of a snapshot */
        AifJobApiFormatFAT32,   /* Format a drive to FAT32 */
        AifJobApiMax = 399,             /* Max API type operation */
        AifJobCtlContinuousCtrVerify,   /* Adapter operation */
        AifJobCtlMax = 499              /* Max Adapter type operation */
} AAC_AifJobType;

struct aac_AifContainers {
        uint32_t        src;            /* from/master */
        uint32_t        dst;            /* to/slave */
};

union aac_AifJobClient {
        struct aac_AifContainers container;     /* For Container and */
                                                /* filesystem progress ops */
        int32_t scsi_dh;                        /* For SCSI progress ops */
};

struct aac_AifJobDesc {
        uint32_t        jobID;  /* DO NOT FILL IN! Will be filled in by AIF */
        AAC_AifJobType  type;   /* Operation that is being performed */
        union aac_AifJobClient  client; /* Details */
};

struct aac_AifJobProgressReport {
        struct aac_AifJobDesc   jd;
        AAC_AifJobStatus        status;
        uint32_t                finalTick;
        uint32_t                currentTick;
        uint32_t                jobSpecificData1;
        uint32_t                jobSpecificData2;
};

/*
 * Event Notification
 */
typedef enum {
        /* General application notifies start here */
        AifEnGeneric = 1,       /* Generic notification */
        AifEnTaskComplete,      /* Task has completed */
        AifEnConfigChange,      /* Adapter config change occurred */
        AifEnContainerChange,   /* Adapter specific container cfg. change */
        AifEnDeviceFailure,     /* SCSI device failed */
        AifEnMirrorFailover,    /* Mirror failover started */
        AifEnContainerEvent,    /* Significant container event */
        AifEnFileSystemChange,  /* File system changed */
        AifEnConfigPause,       /* Container pause event */
        AifEnConfigResume,      /* Container resume event */
        AifEnFailoverChange,    /* Failover space assignment changed */
        AifEnRAID5RebuildDone,  /* RAID5 rebuild finished */
        AifEnEnclosureManagement,       /* Enclosure management event */
        AifEnBatteryEvent,      /* Significant NV battery event */
        AifEnAddContainer,      /* A new container was created. */
        AifEnDeleteContainer,   /* A container was deleted. */
        AifEnSMARTEvent,        /* SMART Event */
        AifEnBatteryNeedsRecond,        /* The battery needs reconditioning */
        AifEnClusterEvent,              /* Some cluster event */
        AifEnDiskSetEvent,              /* A disk set event occured. */
        AifEnAddJBOD = 30,      /* A new JBOD type drive was created (30) */
        AifEnDeleteJBOD = 31,   /* A JBOD type drive was deleted (31) */
        AifDriverNotifyStart = 199,     /* Notifies for host driver go here */
        /* Host driver notifications start here */
        AifDenMorphComplete,            /* A morph operation completed */
        AifDenVolumeExtendComplete      /* Volume expand operation completed */
} AAC_AifEventNotifyType;

struct aac_AifEnsGeneric {
        char    text[132];              /* Generic text */
};

struct aac_AifEnsDeviceFailure {
        uint32_t        deviceHandle;   /* SCSI device handle */
};

struct aac_AifEnsMirrorFailover {
        uint32_t        container;      /* Container with failed element */
        uint32_t        failedSlice;    /* Old slice which failed */
        uint32_t        creatingSlice;  /* New slice used for auto-create */
};

struct aac_AifEnsContainerChange {
        uint32_t        container[2];   /* container that changed, -1 if */
                                        /* no container */
};

struct aac_AifEnsContainerEvent {
        uint32_t        container;      /* container number  */
        uint32_t        eventType;      /* event type */
};

struct aac_AifEnsEnclosureEvent {
        uint32_t        empID;          /* enclosure management proc number  */
        uint32_t        unitID;         /* unitId, fan id, power supply id, */
                                        /* slot id, tempsensor id. */
        uint32_t        eventType;      /* event type */
};

struct aac_AifEnsBatteryEvent {
        AAC_NVBATT_TRANSITION   transition_type;        /* eg from low to ok */
        AAC_NVBATTSTATUS        current_state;  /* current batt state */
        AAC_NVBATTSTATUS        prior_state;    /* prev batt state */
};

struct aac_AifEnsDiskSetEvent {
        uint32_t        eventType;
        uint64_t        DsNum;
        uint64_t        CreatorId;
};

typedef enum {
        CLUSTER_NULL_EVENT = 0,
        CLUSTER_PARTNER_NAME_EVENT,     /* change in partner hostname or */
                                        /* adaptername from NULL to non-NULL */
                                        /* (partner's agent may be up) */
        CLUSTER_PARTNER_NULL_NAME_EVENT /* change in partner hostname or */
                                        /* adaptername from non-null to NULL */
                                        /* (partner has rebooted) */
} AAC_ClusterAifEvent;

struct aac_AifEnsClusterEvent {
        AAC_ClusterAifEvent     eventType;
};

struct aac_AifEventNotify {
        AAC_AifEventNotifyType  type;
        union {
                struct aac_AifEnsGeneric                EG;
                struct aac_AifEnsDeviceFailure          EDF;
                struct aac_AifEnsMirrorFailover         EMF;
                struct aac_AifEnsContainerChange        ECC;
                struct aac_AifEnsContainerEvent         ECE;
                struct aac_AifEnsEnclosureEvent         EEE;
                struct aac_AifEnsBatteryEvent           EBE;
                struct aac_AifEnsDiskSetEvent           EDS;
/*              struct aac_AifEnsSMARTEvent             ES; */
                struct aac_AifEnsClusterEvent           ECLE;
        } data;
};

/*
 * Adapter Initiated FIB command structures. Start with the adapter
 * initiated FIBs that really come from the adapter, and get responded
 * to by the host.
 */
#define AAC_AIF_REPORT_MAX_SIZE 64

typedef enum {
        AifCmdEventNotify = 1,  /* Notify of event */
        AifCmdJobProgress,      /* Progress report */
        AifCmdAPIReport,        /* Report from other user of API */
        AifCmdDriverNotify,     /* Notify host driver of event */
        AifReqJobList = 100,    /* Gets back complete job list */
        AifReqJobsForCtr,       /* Gets back jobs for specific container */
        AifReqJobsForScsi,      /* Gets back jobs for specific SCSI device */
        AifReqJobReport,        /* Gets back a specific job report or list */
        AifReqTerminateJob,     /* Terminates job */
        AifReqSuspendJob,       /* Suspends a job */
        AifReqResumeJob,        /* Resumes a job */
        AifReqSendAPIReport,    /* API generic report requests */
        AifReqAPIJobStart,      /* Start a job from the API */
        AifReqAPIJobUpdate,     /* Update a job report from the API */
        AifReqAPIJobFinish      /* Finish a job from the API */
} AAC_AifCommand;

struct aac_aif_command {
        AAC_AifCommand  command; /* Tell host what type of notify this is */
        uint32_t        seqNumber;      /* To allow ordering of reports */
                                        /* (if necessary) */
        union {
                struct aac_AifEventNotify       EN;     /* Event notify */
                struct aac_AifJobProgressReport PR[1];  /* Progress report */
                uint8_t AR[AAC_AIF_REPORT_MAX_SIZE];
                uint8_t data[AAC_FIB_DATASIZE - 8];
        } data;
};

#define CT_PUP_MISSING_DRIVE    27

/*
 * Cluster Management Commands
 */
typedef enum {
        CL_NULL = 0,            /* 0x00 null */
        /* disk set commands */
        DS_INIT = 1,            /* 0x01 init disk set control block */
        DS_RESCAN,              /* 0x02 refresh drive, disk set, and slice */
                                /* structs */
        DS_CREATE,              /* 0x03 create a disk set */
        DS_DELETE,              /* 0x04 delete a disk set */
        DS_ADD_DISK,            /* 0x05 add a disk to an existing disk set */
        DS_REMOVE_DISK,         /* 0x06 remove a disk from an existing disk */
                                /* set */
        DS_MOVE_DISK,           /* 0x07 move a disk from one existing disk */
                                /* set to another */
        DS_TAKE_OWNERSHIP,      /* 0x08 take ownership of an unowned disk set */
        DS_RELEASE_OWNERSHIP,   /* 0x09 release ownership of a disk set */
        DS_FORCE_OWNERSHIP,     /* 0x0A force ownership of an disk set */
        DS_GET_DISK_SET_PARAM,  /* 0x0B get info on a disk set */
        DS_GET_DRIVE_PARAM,     /* 0x0C get info on a drive */
        DS_GET_SLICE_PARAM,     /* 0x0D get info on a slice */
        DS_GET_DISK_SETS,       /* 0x0E get a list of disk sets */
        DS_GET_DRIVES,          /* 0x0F get a list of drives */
        DS_SET_DISK_SET_PARAM,  /* 0x10 set info of a disk set */
        DS_ONLINE,              /* 0x11 take disk set online */
        DS_OFFLINE,             /* 0x12 take disk set offline */
        DS_ONLINE_CONTAINERS,   /* 0x13 bring containers in diskset online */
        DS_FSAPRINT,            /* 0x14 do an FsaPrint */

        /* config commands */
        CL_CFG_SET_HOST_IDS = 0x100,    /* 0x100 set host ids (host name and */
                                        /* adapter name) */
        CL_CFG_SET_PARTNER_HOST_IDS,    /* 0x101 set partner host ids (host */
                                        /* name and adapter name) */
        CL_CFG_GET_CLUSTER_CONFIG,      /* 0x102 get cluster configuration */

        /* cluster comm commands */
        CC_CLI_CLEAR_MESSAGE_BUFFER = 0x200,    /* 0x200 CC - client - clear */
                                                /* contents of message buffer */
        CC_SRV_CLEAR_MESSAGE_BUFFER,    /* 0x201 CC - server - clear contents */
                                        /* of message buffer */
        CC_CLI_SHOW_MESSAGE_BUFFER,     /* 0x202 CC - client - show contents */
                                        /* of message buffer */
        CC_SRV_SHOW_MESSAGE_BUFFER,     /* 0x203 CC - server - show contents */
                                        /* of message buffer */
        CC_CLI_SEND_MESSAGE,    /* 0x204 CC - client - send (req) message to */
                                /* server side */
        CC_SRV_SEND_MESSAGE,    /* 0x205 CC - server - send (reply) message */
                                /* to client side */
        CC_CLI_GET_MESSAGE,     /* 0x206 CC - client - read thru read message */
                                /* buffer */
        CC_SRV_GET_MESSAGE,     /* 0x207 CC - server - read thru read message */
                                /* buffer */
        CC_SEND_TEST_MESSAGE,   /* 0x208 CC - send a special subclass message */
        CC_GET_BUSINFO,         /* 0x209 CC - get bus info */
        CC_GET_PORTINFO,        /* 0x20A CC - get bus,port info */
        CC_GET_NAMEINFO,        /* 0x20B CC - get misc info */
        CC_GET_CONFIGINFO,      /* 0x20C CC - get misc info */
        CQ_QUORUM_OP = 0x300,   /* 0x300 CQ - quorum messages */

        /* last command */
        CL_LAST_COMMAND         /* used for bounds checking */
} AAC_CLCommand;

/*
 * Disk IOCTL Functions
 */
#define Reserved_IOCTL                  0x0000
#define GetDeviceHandle                 0x0001
#define BusTargetLun_to_DeviceHandle    0x0002
#define DeviceHandle_to_BusTargetLun    0x0003
#define RescanBus                       0x0004
#define GetDeviceProbeInfo              0x0005
#define GetDeviceCapacity               0x0006
#define GetContainerProbeInfo           0x0007  /* Container, not diskclass */
                                                /* ioctl */
#define GetRequestedMemorySize          0x0008
#define GetBusInfo                      0x0009
#define GetVendorSpecific               0x000a

#define EnhancedGetDeviceProbeInfo      0x000b
#define EnhancedGetBusInfo              0x000c

#define SetupExtendedCounters           0x000d
#define GetPerformanceCounters          0x000f
#define ResetPerformanceCounters        0x0010
#define ReadModePage                    0x0011
#define WriteModePage                   0x0012
#define ReadDriveParameter              0x0013
#define WriteDriveParameter             0x0014
#define ResetAdapter                    0x0015
#define ResetBus                        0x0016
#define ResetBusDevice                  0x0017
#define ExecuteSrb                      0x0018

#define Create_IO_Task                  0x0030
#define Delete_IO_Task                  0x0031
#define Get_IO_Task_Info                0x0032
#define Check_Task_Progress             0x0033

#define InjectError                     0x0040
#define GetDeviceDefectCounts           0x0041
#define GetDeviceDefectInfo             0x0042
#define GetDeviceStatus                 0x0043
#define ClearDeviceStatus               0x0044
#define DiskSpinControl                 0x0045
#define DiskSmartControl                0x0046
#define WriteSame                       0x0047
#define ReadWriteLong                   0x0048
#define FormatUnit                      0x0049

#define TargetDeviceControl             0x0050
#define TargetChannelControl            0x0051

#define FlashNewCode                    0x0052
#define DiskCheck                       0x0053
#define RequestSense                    0x0054
#define DiskPERControl                  0x0055
#define Read10                          0x0056
#define Write10                         0x0057

/*
 * The following definitions come from Adaptec:
 *
 * SRB is required for the new management tools
 * and non-DASD support.
 */
struct aac_srb
{
        uint32_t function;
        uint32_t channel;
        uint32_t id;
        uint32_t lun;
        uint32_t timeout;       /* timeout in sec. */
        uint32_t flags;
        uint32_t count;         /* data xfer size */
        uint32_t retry_limit;   /* obsolete */
        uint32_t cdb_size;
        uint8_t cdb[16];
        struct aac_sg_table sg;
};

#define AAC_SENSE_BUFFERSIZE     30

struct aac_srb_reply
{
        uint32_t status;
        uint32_t srb_status;
        uint32_t scsi_status;
        uint32_t data_xfer_length;
        uint32_t sense_data_size;
        uint8_t sense_data[AAC_SENSE_BUFFERSIZE];
};

/*
 * SRB Flags
 */
#define SRB_NoDataXfer                  0x0000
#define SRB_DisableDisconnect           0x0004
#define SRB_DisableSynchTransfer        0x0008
#define SRB_BypassFrozenQueue           0x0010
#define SRB_DisableAutosense            0x0020
#define SRB_DataIn                      0x0040
#define SRB_DataOut                     0x0080

/*
 * SRB Functions - set in aac_srb->function
 */
#define SRBF_ExecuteScsi                0x0000
#define SRBF_ClaimDevice                0x0001
#define SRBF_IO_Control                 0x0002
#define SRBF_ReceiveEvent               0x0003
#define SRBF_ReleaseQueue               0x0004
#define SRBF_AttachDevice               0x0005
#define SRBF_ReleaseDevice              0x0006
#define SRBF_Shutdown                   0x0007
#define SRBF_Flush                      0x0008
#define SRBF_AbortCommand               0x0010
#define SRBF_ReleaseRecovery            0x0011
#define SRBF_ResetBus                   0x0012
#define SRBF_ResetDevice                0x0013
#define SRBF_TerminateIO                0x0014
#define SRBF_FlushQueue                 0x0015
#define SRBF_RemoveDevice               0x0016
#define SRBF_DomainValidation           0x0017

/*
 * SRB SCSI Status
 * Status codes for SCSI passthrough commands,
 * set in aac_srb->scsi_status
 */
#define SRB_STATUS_PENDING                      0x00
#define SRB_STATUS_SUCCESS                      0x01
#define SRB_STATUS_ABORTED                      0x02
#define SRB_STATUS_ABORT_FAILED                 0x03
#define SRB_STATUS_ERROR                        0x04
#define SRB_STATUS_BUSY                         0x05
#define SRB_STATUS_INVALID_REQUEST              0x06
#define SRB_STATUS_INVALID_PATH_ID              0x07
#define SRB_STATUS_NO_DEVICE                    0x08
#define SRB_STATUS_TIMEOUT                      0x09
#define SRB_STATUS_SELECTION_TIMEOUT            0x0A
#define SRB_STATUS_COMMAND_TIMEOUT              0x0B
#define SRB_STATUS_MESSAGE_REJECTED             0x0D
#define SRB_STATUS_BUS_RESET                    0x0E
#define SRB_STATUS_PARITY_ERROR                 0x0F
#define SRB_STATUS_REQUEST_SENSE_FAILED         0x10
#define SRB_STATUS_NO_HBA                       0x11
#define SRB_STATUS_DATA_OVERRUN                 0x12
#define SRB_STATUS_UNEXPECTED_BUS_FREE          0x13
#define SRB_STATUS_PHASE_SEQUENCE_FAILURE       0x14
#define SRB_STATUS_BAD_SRB_BLOCK_LENGTH         0x15
#define SRB_STATUS_REQUEST_FLUSHED              0x16
#define SRB_STATUS_DELAYED_RETRY                0x17
#define SRB_STATUS_INVALID_LUN                  0x20
#define SRB_STATUS_INVALID_TARGET_ID            0x21
#define SRB_STATUS_BAD_FUNCTION                 0x22
#define SRB_STATUS_ERROR_RECOVERY               0x23
#define SRB_STATUS_NOT_STARTED                  0x24
#define SRB_STATUS_NOT_IN_USE                   0x30
#define SRB_STATUS_FORCE_ABORT                  0x31
#define SRB_STATUS_DOMAIN_VALIDATION_FAIL       0x32

#pragma pack()

/*
 * Aligned structure definition for variable declarations that require
 * alignment.
 */
union aac_fib_align {
        struct aac_fib d;
        uint32_t dumb;
};

/* AAC Communication Space */
struct aac_comm_space {
        struct aac_fib adapter_fibs[AAC_ADAPTER_FIBS];
        struct aac_adapter_init init_data;
        struct aac_queue_table qtable;
        char qt_align_pad[AAC_QUEUE_ALIGN];
        char adapter_print_buf[AAC_ADAPTER_PRINT_BUFSIZE];
};

#ifdef  __cplusplus
}
#endif

#endif /* __AAC_REGS_H__ */