#ifndef __MV_COM_TYPE_H__ | |
#define __MV_COM_TYPE_H__ | |
#include "com_define.h" | |
#include "com_list.h" | |
#include "mv_config.h" // USE_NEW_SGTABLE is defined in mv_config.h | |
/* | |
* Data Structure | |
*/ | |
#define MAX_CDB_SIZE 16 | |
struct _MV_Request; | |
typedef struct _MV_Request MV_Request, *PMV_Request; | |
#ifdef RAID_DRIVER | |
typedef struct _MV_XOR_Request MV_XOR_Request, *PMV_XOR_Request; | |
#endif /* RAID_DRIVER */ | |
#define REQ_STATUS_SUCCESS 0x0 | |
#define REQ_STATUS_NOT_READY 0x1 | |
#define REQ_STATUS_MEDIA_ERROR 0x2 | |
#define REQ_STATUS_BUSY 0x3 | |
#define REQ_STATUS_INVALID_REQUEST 0x4 | |
#define REQ_STATUS_INVALID_PARAMETER 0x5 | |
#define REQ_STATUS_NO_DEVICE 0x6 | |
/* Sense data structure is the SCSI "Fixed format sense datat" format. */ | |
#define REQ_STATUS_HAS_SENSE 0x7 | |
#define REQ_STATUS_ERROR 0x8 | |
#define REQ_STATUS_ERROR_WITH_SENSE 0x10 | |
/* Request initiator must set the status to REQ_STATUS_PENDING. */ | |
#define REQ_STATUS_PENDING 0x80 | |
#define REQ_STATUS_RETRY 0x81 | |
#define REQ_STATUS_REQUEST_SENSE 0x82 | |
#define REQ_STATUS_ABORT 0x83 | |
/* | |
* Don't change the order here. | |
* Module_StartAll will start from big id to small id. | |
* Make sure module_set setting matches the Module_Id | |
* MODULE_HBA must be the first one. Refer to Module_AssignModuleExtension. | |
* And HBA_GetNextModuleSendFunction has an assumption that the next level | |
* has larger ID. | |
*/ | |
enum Module_Id | |
{ | |
MODULE_HBA = 0, | |
#ifdef CACHE_MODULE_SUPPORT | |
MODULE_CACHE, | |
#endif /* CACHE_MODULE_SUPPORT */ | |
#ifdef RAID_DRIVER | |
MODULE_RAID, | |
#endif /* RAID_DRIVER */ | |
MODULE_CORE, | |
MAX_MODULE_NUMBER | |
}; | |
#define MAX_POSSIBLE_MODULE_NUMBER MAX_MODULE_NUMBER | |
#ifdef USE_NEW_SGTABLE | |
#include "com_sgd.h" | |
typedef sgd_tbl_t MV_SG_Table, *PMV_SG_Table; | |
typedef sgd_t MV_SG_Entry, *PMV_SG_Entry; | |
#else | |
struct _MV_SG_Table; | |
typedef struct _MV_SG_Table MV_SG_Table, *PMV_SG_Table; | |
struct _MV_SG_Entry; | |
typedef struct _MV_SG_Entry MV_SG_Entry, *PMV_SG_Entry; | |
/* SG Table and SG Entry */ | |
struct _MV_SG_Entry | |
{ | |
MV_U32 Base_Address; | |
MV_U32 Base_Address_High; | |
MV_U32 Reserved0; | |
MV_U32 Size; | |
}; | |
struct _MV_SG_Table | |
{ | |
MV_U8 Max_Entry_Count; | |
MV_U8 Valid_Entry_Count; | |
MV_U8 Flag; | |
MV_U8 Reserved0; | |
MV_U32 Byte_Count; | |
PMV_SG_Entry Entry_Ptr; | |
}; | |
#endif | |
#ifdef SIMULATOR | |
#define MV_REQ_COMMON_SCSI 0 | |
#define MV_REQ_COMMON_XOR 1 | |
#endif /*SIMULATOR*/ | |
/* | |
* MV_Request is the general request type passed through different modules. | |
* Must be 64 bit aligned. | |
*/ | |
#define DEV_ID_TO_TARGET_ID(_dev_id) ((MV_U8)((_dev_id) & 0x00FF)) | |
#define DEV_ID_TO_LUN(_dev_id) ((MV_U8) (((_dev_id) & 0xFF00) >> 8)) | |
#define __MAKE_DEV_ID(_target_id, _lun) (((MV_U16)(_target_id)) | (((MV_U16)(_lun)) << 8)) | |
/*Work around free disks suporting temporarily*/ | |
#define RESTORE_FREE_DISK_TID 1 | |
typedef void (*MV_ReqCompletion)(MV_PVOID,PMV_Request); | |
struct _MV_Request { | |
#ifdef SIMULATOR | |
MV_U32 CommonType; // please keep it as the first field | |
#endif /* SIMULATOR */ | |
#ifdef __RES_MGMT__ | |
List_Head pool_entry; /* don't bother, res_mgmt use only */ | |
#endif /* __RES_MGMT__ */ | |
List_Head Queue_Pointer; | |
List_Head Complete_Queue_Pointer; | |
#if defined(_OS_LINUX) || defined(__QNXNTO__) | |
List_Head hba_eh_entry; /* hba's request queue */ | |
#endif /* _OS_LINUX || __QNXNTO__ */ | |
MV_U16 Device_Id; | |
MV_U16 Req_Flag; /* Check the REQ_FLAG definition */ | |
MV_U8 Scsi_Status; | |
MV_U8 Tag; /* Request tag */ | |
MV_U8 Req_Type; /* Check the REQ_TYPE definition */ | |
#ifdef _OS_WINDOWS | |
MV_U8 Reserved0[1]; | |
#elif defined(SUPPORT_ERROR_HANDLING) && defined(_OS_LINUX) | |
MV_U8 eh_flag; /* mark a req after it is re-inserted into | |
* waiting_list due to error handling. | |
*/ | |
#else | |
MV_U8 Reserved0[1]; | |
#endif /* _OS_WINDOWS */ | |
MV_PVOID Cmd_Initiator; /* Which module(extension pointer) | |
creates this request. */ | |
MV_U8 Sense_Info_Buffer_Length; | |
#if RESTORE_FREE_DISK_TID | |
MV_U8 org_target_id; | |
#else | |
MV_U8 Reserved1; | |
#endif | |
MV_U16 SlotNo; | |
MV_U32 Data_Transfer_Length; | |
MV_U8 Cdb[MAX_CDB_SIZE]; | |
MV_PVOID Data_Buffer; | |
MV_PVOID Sense_Info_Buffer; | |
MV_SG_Table SG_Table; | |
MV_PVOID Org_Req; /* The original request. */ | |
/* Each module should only use Context to store module information. */ | |
MV_PVOID Context[MAX_POSSIBLE_MODULE_NUMBER]; | |
MV_PVOID Scratch_Buffer; /* pointer to the scratch buffer | |
that this request used */ | |
MV_PVOID SG_Buffer; | |
MV_PVOID pRaid_Request; | |
MV_LBA LBA; | |
MV_U32 Sector_Count; | |
MV_U32 Cmd_Flag; | |
MV_U32 Time_Out; /* how many seconds we should wait | |
before treating request as | |
timed-out */ | |
MV_U32 Splited_Count; | |
#if ERROR_HANDLING_SUPPORT | |
MV_U8 bh_eh_flag; | |
MV_U8 reserved[3]; | |
MV_PVOID bh_eh_ctx; /*The type should be MV_PVOID*/ | |
#endif /* ERROR_HANDLING_SUPPORT */ | |
#ifdef _OS_LINUX | |
MV_DECLARE_TIMER(eh_timeout); | |
#ifdef SUPPORT_REQUEST_TIMER | |
MV_PVOID err_request_ctx; | |
#endif | |
#endif /* _OS_LINUX */ | |
#ifdef _OS_LINUX | |
#ifdef _32_LEGACY_ | |
MV_U8 dummy[5]; | |
#endif | |
#endif /* _OS_LINUX */ | |
MV_ReqCompletion Completion; /* call back function */ | |
}; | |
#define MV_REQUEST_SIZE sizeof(MV_Request) | |
/* | |
* Request flag is the flag for the MV_Request data structure. | |
*/ | |
#define REQ_FLAG_LBA_VALID MV_BIT(0) | |
#define REQ_FLAG_CMD_FLAG_VALID MV_BIT(1) | |
#define REQ_FLAG_RETRY MV_BIT(2) | |
#define REQ_FLAG_INTERNAL_SG MV_BIT(3) | |
#ifndef USE_NEW_SGTABLE | |
#define REQ_FLAG_USE_PHYSICAL_SG MV_BIT(4) | |
#define REQ_FLAG_USE_LOGICAL_SG MV_BIT(5) | |
#else | |
/*temporarily reserve bit 4 & 5 until NEW_SG is enabled fixedly for all OS */ | |
#endif | |
#define REQ_FLAG_FLUSH MV_BIT(6) | |
#define REQ_FLAG_CONSOLIDATE MV_BIT(8) | |
#define REQ_FLAG_NO_CONSOLIDATE MV_BIT(9) | |
#define REQ_FLAG_EXTERNAL MV_BIT(10) | |
#define REQ_FLAG_CORE_SUB MV_BIT(11) | |
#define REQ_FLAG_BYPASS_HYBRID MV_BIT(12) // hybrid disk simulation | |
/* | |
* Request Type is the type of MV_Request. | |
*/ | |
enum { | |
/* use a value other than 0, and now they're bit-mapped */ | |
REQ_TYPE_OS = 0x01, | |
REQ_TYPE_RAID = 0x02, | |
REQ_TYPE_CACHE = 0x04, | |
REQ_TYPE_INTERNAL = 0x08, | |
REQ_TYPE_SUBLD = 0x10, | |
REQ_TYPE_SUBBGA = 0x20, | |
REQ_TYPE_MP = 0x40, | |
}; | |
/* | |
* Command flag is the flag for the CDB command itself | |
*/ | |
/* The first 16 bit can be determined by the initiator. */ | |
#define CMD_FLAG_NON_DATA MV_BIT(0) /* 1-non data; | |
0-data command */ | |
#define CMD_FLAG_DMA MV_BIT(1) /* 1-DMA */ | |
#define CMD_FLAG_PIO MV_BIT(2) /* 1-PIO */ | |
#define CMD_FLAG_DATA_IN MV_BIT(3) /* 1-host read data */ | |
#define CMD_FLAG_DATA_OUT MV_BIT(4) /* 1-host write data */ | |
#define CMD_FLAG_SMART MV_BIT(5) /* 1-SMART command;0-non SMART command*/ | |
#define CMD_FLAG_SMART_ATA_12 MV_BIT(6) /* SMART ATA_12 */ | |
#define CMD_FLAG_SMART_ATA_16 MV_BIT(7) /* SMART ATA_16; */ | |
/* | |
* The last 16 bit only can be set by the target. Only core driver knows | |
* the device characteristic. | |
*/ | |
#define CMD_FLAG_NCQ MV_BIT(16) | |
#define CMD_FLAG_TCQ MV_BIT(17) | |
#define CMD_FLAG_48BIT MV_BIT(18) | |
#define CMD_FLAG_PACKET MV_BIT(19) /* ATAPI packet cmd */ | |
#define CMD_FLAG_SCSI_PASS_THRU MV_BIT(20) | |
#define CMD_FLAG_ATA_PASS_THRU MV_BIT(21) | |
#ifdef RAID_DRIVER | |
/* XOR request types */ | |
#define XOR_REQUEST_WRITE 0 | |
#define XOR_REQUEST_COMPARE 1 | |
#define XOR_REQUEST_DMA 2 | |
/* XOR request status */ | |
#define XOR_STATUS_SUCCESS 0 | |
#define XOR_STATUS_INVALID_REQUEST 1 | |
#define XOR_STATUS_ERROR 2 | |
#define XOR_STATUS_INVALID_PARAMETER 3 | |
#define XOR_SOURCE_SG_COUNT 11 | |
#ifdef RAID6_MULTIPLE_PARITY | |
# define XOR_TARGET_SG_COUNT 3 | |
#else | |
# define XOR_TARGET_SG_COUNT 1 | |
#endif | |
typedef MV_U8 XOR_COEF, *PXOR_COEF; /* XOR Coefficient */ | |
struct _MV_XOR_Request { | |
#ifdef SIMULATOR | |
MV_U32 CommonType; // please keep it as the first field | |
#endif /*SIMULATOR*/ | |
List_Head Queue_Pointer; | |
MV_U16 Device_Id; | |
MV_U8 Request_Type; | |
MV_U8 Request_Status; | |
MV_U8 Source_SG_Table_Count; /* how many items in the | |
SG_Table_List */ | |
MV_U8 Target_SG_Table_Count; | |
#ifdef SOFTWARE_XOR | |
MV_U8 Reserved[2]; | |
#else | |
MV_U16 SlotNo; | |
#endif /* SOFTWARE_XOR */ | |
MV_SG_Table Source_SG_Table_List[XOR_SOURCE_SG_COUNT]; | |
MV_SG_Table Target_SG_Table_List[XOR_TARGET_SG_COUNT]; | |
XOR_COEF Coef[XOR_TARGET_SG_COUNT][XOR_SOURCE_SG_COUNT]; | |
MV_U32 Error_Offset; /* byte, not sector */ | |
MV_PVOID Cmd_Initiator; /* Which module(extension pointer | |
) creates this request. */ | |
#ifdef RAID6_HARDWARE_XOR | |
MV_PVOID Context[MAX_POSSIBLE_MODULE_NUMBER]; | |
#else | |
MV_PVOID Context; | |
#endif | |
MV_PVOID SG_Buffer; | |
void (*Completion)(MV_PVOID, PMV_XOR_Request); /* callback */ | |
}; | |
#endif /* RAID_DRIVER */ | |
typedef struct _MV_Target_ID_Map | |
{ | |
MV_U16 Device_Id; | |
MV_U8 Type; /* 0:LD, 1:Free Disk */ | |
MV_U8 Reserved; | |
} MV_Target_ID_Map, *PMV_Target_ID_Map; | |
/* Resource type */ | |
enum Resource_Type | |
{ | |
RESOURCE_CACHED_MEMORY = 0, | |
#ifdef SUPPORT_DISCARDABLE_MEM | |
RESOURCE_DISCARDABLE_MEMORY, | |
#endif | |
RESOURCE_UNCACHED_MEMORY | |
}; | |
/* Module event type */ | |
enum Module_Event | |
{ | |
EVENT_MODULE_ALL_STARTED = 0, | |
#ifdef CACHE_MODULE_SUPPORT | |
EVENT_DEVICE_CACHE_MODE_CHANGED, | |
#endif /* CACHE_MODULE_SUPPORT */ | |
#ifdef SUPPORT_DISCARDABLE_MEM | |
EVENT_SPECIFY_RUNTIME_DEVICE, | |
EVENT_DISCARD_RESOURCE, | |
#endif | |
EVENT_DEVICE_ARRIVAL, | |
EVENT_DEVICE_REMOVAL, | |
EVENT_LOG_GENERATED, | |
EVENT_HOT_PLUG, | |
}; | |
/* Error_Handling_State */ | |
enum EH_State | |
{ | |
EH_NONE = 0, | |
EH_ABORT_REQUEST, | |
EH_LU_RESET, | |
EH_DEVICE_RESET, | |
EH_PORT_RESET, | |
EH_CHIP_RESET, | |
EH_SET_DISK_DOWN | |
}; | |
typedef enum | |
{ | |
EH_REQ_NOP = 0, | |
EH_REQ_ABORT_REQUEST, | |
EH_REQ_HANDLE_TIMEOUT, | |
EH_REQ_RESET_BUS, | |
EH_REQ_RESET_CHANNEL, | |
EH_REQ_RESET_DEVICE, | |
EH_REQ_RESET_ADAPTER | |
}eh_req_type_t; | |
struct mod_notif_param { | |
MV_PVOID p_param; | |
MV_U16 hi; | |
MV_U16 lo; | |
/* for event processing */ | |
MV_U32 event_id; | |
MV_U16 dev_id; | |
MV_U8 severity_lvl; | |
MV_U8 param_count; | |
}; | |
/* | |
* Exposed Functions | |
*/ | |
/* | |
* | |
* Miscellaneous Definitions | |
* | |
*/ | |
/* Rounding */ | |
/* Packed */ | |
#define MV_MAX(x,y) (((x) > (y)) ? (x) : (y)) | |
#define MV_MIN(x,y) (((x) < (y)) ? (x) : (y)) | |
#define MV_MAX_U64(x, y) ((((x).value) > ((y).value)) ? (x) : (y)) | |
#define MV_MIN_U64(x, y) ((((x).value) < ((y).value)) ? (x) : (y)) | |
#define MV_MAX_U8 0xFF | |
#define MV_MAX_U16 0xFFFF | |
#define MV_MAX_U32 0xFFFFFFFFL | |
#ifdef _OS_LINUX | |
# define ROUNDING_MASK(x, mask) (((x)+(mask))&~(mask)) | |
# define ROUNDING(value, align) ROUNDING_MASK(value, \ | |
(typeof(value)) (align-1)) | |
# define OFFSET_OF(type, member) offsetof(type, member) | |
#else | |
# define ROUNDING(value, align) ( ((value)+(align)-1)/(align)*(align) ) | |
# define OFFSET_OF(type, member) ((MV_U32)(MV_PTR_INTEGER)&(((type *) 0)->member)) | |
# define ALIGN ROUNDING | |
#endif /* _OS_LINUX */ | |
#endif /* __MV_COM_TYPE_H__ */ |