diff options
| author | Javier <dev.git@javispedro.com> | 2026-10-26 00:50:06 +0100 |
|---|---|---|
| committer | Javier <dev.git@javispedro.com> | 2026-10-26 00:50:06 +0100 |
| commit | 6b8a368c51082fdd010ef5e1b0be4eb9b5059d1a (patch) | |
| tree | e274d41a8dd5e912e20617a937a1fda5af91f8de /w9x/inc/ios.h | |
| parent | 9b1cf601360fb194047e6dcc2af75c2f38c611ec (diff) | |
| download | chu-6b8a368c51082fdd010ef5e1b0be4eb9b5059d1a.tar.gz chu-6b8a368c51082fdd010ef5e1b0be4eb9b5059d1a.zip | |
refactor common parts into inc/ch375.h and add win9x, linux drivers
Diffstat (limited to 'w9x/inc/ios.h')
| -rw-r--r-- | w9x/inc/ios.h | 1520 |
1 files changed, 1520 insertions, 0 deletions
diff --git a/w9x/inc/ios.h b/w9x/inc/ios.h new file mode 100644 index 0000000..59214d8 --- /dev/null +++ b/w9x/inc/ios.h @@ -0,0 +1,1520 @@ +#ifndef IOS_H +#define IOS_H + +/** This is a big mess of IOS structs and functions. + * They come from the storage.doc / FAQ. + * There are also some VxDCall wrappers, manually generated. + */ + +#include <stddef.h> +#include <stdint.h> +#include "sassert.h" + +typedef void __cdecl (*IO_callback)(struct IOP *iop); + +// IOS ================ + +#define IOS_DEVICE_ID 0x10 + +static inline uint32_t IOS_Get_Version(void); +#pragma aux IOS_Get_Version = \ + "int 0x20" \ + "dd ( 0x10 shl 16 ) + 0" \ + "jnc ok" \ + "xor eax, eax" \ + "ok:" \ + __parm __caller [] __value [eax] __modify [ecx edx] + +static inline void IOS_Register(const struct DRP *drp); +#pragma aux IOS_Register = \ + "int 0x20" \ + "dd ( 0x10 shl 16 ) + 7" \ + __parm __caller [] __modify [eax ecx edx] + +// AEP ================ + +typedef _Packed struct AEPHDR { + uint16_t AEP_func; // function; see below + uint16_t AEP_result; // result; set to zero if successful; see below + uint32_t AEP_ddb; // address of DDB + uint8_t AEP_lgn; // current load group number (from DVT) + uint8_t AEP_align[3]; // reserved; don't use +} AEPHDR, *PAEPHDR; + +typedef _Packed struct AEP_bi_init { + AEPHDR AEP_bi_i_hdr; + uint32_t AEP_bi_reference_data; // optional value passed in from DRP + uint8_t AEP_bi_flags; // flags; see below + uint8_t AEP_bi_i_max_target; // max scsi target id + uint8_t AEP_bi_i_max_lun; // max scsi lun + uint32_t AEP_bi_i_dcb; // init DCB for port drivers + void* AEP_bi_i_hdevnode; // handle to devnode for this adapter + void* AEP_bi_i_regkey; // registry key for this adapter + uint8_t AEP_bi_i_align[1]; // reserved; don't use +} AEP_bi_init, *PAEP_bi_init; + +typedef _Packed struct AEP_boot_done { + AEPHDR AEP_bi_i_hdr; +} AEP_boot_done, *PAEP_boot_done; + +typedef _Packed struct AEP_dcb_config { + struct AEPHDR AEP_d_c_hdr; + struct DCB *AEP_d_c_dcb; // 32-bit ptr to DCB +} AEP_dcb_config, *PAEP_dcb_config; + +typedef _Packed struct AEP_dcb_unconfig { + struct AEPHDR AEP_d_u_hdr; + struct DCB *AEP_d_u_dcb; // 32-bit ptr to DCB +} AEP_dcb_unconfig, *PAEP_dcb_unconfig; + +typedef _Packed struct AEP_iop_timeout_occurred { + struct AEPHDR AEP_i_t_o_hdr; + struct IOP *AEP_i_t_o_iop; // address of IOP that timed out +} AEP_iop_timeout_occurred, *PAEP_iop_timeout_occurred; + +typedef _Packed struct AEP_inquiry_device { + struct AEPHDR AEP_i_d_hdr; + uint32_t AEP_i_d_dcb; // address of DCB +} AEP_inquiry_device, *PAEP_inquiry_device; + +typedef _Packed struct AEP_bi_uninit { + struct AEPHDR AEP_bi_u_hdr; +} AEP_bi_uninit, *PAEP_bi_uninit; + +typedef struct AEP_dcb_unconfig_pend { + struct AEPHDR AEP_d_u_p_hdr; + struct DCB *AEP_d_u_p_dcb; // 32-bit ptr to DCB +} AEP_dcb_unconfig_pend, *PAEP_dcb_unconfig_pend; + +typedef _Packed union AEP { + struct AEPHDR; + struct AEP_bi_init bi_i; + struct AEP_boot_done b_d; + struct AEP_dcb_config d_c; + struct AEP_dcb_unconfig d_u; + struct AEP_iop_timeout_occurred i_t_o; + struct AEP_inquiry_device i_d; + struct AEP_bi_uninit bi_u; + struct AEP_dcb_unconfig_pend d_u_p; +} AEP, *PAEP; + +typedef enum AEP_result { + AEP_SUCCESS = 0, + AEP_FAILURE = -1, + + AEP_NO_INQ_DATA = 1, + AEP_NO_MORE_DEVICES = 2 +} AEP_result; + +enum AEP_funcs { + /** initializes driver/interface */ + AEP_INITIALIZE = 0, + /** indicates system critical shutdown */ + AEP_SYSTEM_CRIT_SHUTDOWN = 1, + /** booting done - switch to run time */ + AEP_BOOT_COMPLETE = 2, + /* configure device */ + AEP_CONFIG_DCB = 3, + /* unconfigure device */ + AEP_UNCONFIG_DCB = 4, + /* iop timeout occured */ + AEP_IOP_TIMEOUT = 5, + /* get device indentification data */ + AEP_DEVICE_INQUIRY = 6, + /* 1/2 second interval notification */ + AEP_HALF_SEC = 7, + /* one second interval notification */ + AEP_1_SEC = 8, + /* two second interval notification */ + AEP_2_SECS = 9, + /* four second interval notification*/ + AEP_4_SECS = 10, + /* parameters for '.I' debug command*/ + AEP_DBG_DOT_CMD = 11, + /* associate logical DCBs w/ physical */ + AEP_ASSOCIATE_DCB = 12, + /* IFSMGR about to hook in */ + AEP_REAL_MODE_HANDOFF = 13, + /* indicates system shutdown */ + AEP_SYSTEM_SHUTDOWN = 14, + /* uninitialize driver/interface */ + AEP_UNINITIALIZE = 15, + /* logical dcb is going to be locked */ + AEP_DCB_LOCK = 16, + /* notify drivers of volume mount */ + AEP_MOUNT_NOTIFY = 17, + /* notify drivers of VRP creation */ + AEP_CREATE_VRP = 18, + /* notify drivers of VRP destruction */ + AEP_DESTROY_VRP = 19, + /* tell drivers to refresh drive data */ + AEP_REFRESH_DRIVE = 20, + /** tell drivers that DCB removal is pending */ + AEP_PEND_UNCONFIG_DCB = 21, + /** notify int13 of a possible change in the int 1eh vector for copy protection */ + AEP_1E_VEC_UPDATE = 22, + /** inform driver vsd to change the floppy spindle speed */ + AEP_CHANGE_RPM = 23, +}; + +// BlockDev =========== + +typedef struct BlockDev_Scatter_Gather{ + uint32_t BD_SG_Count; // Block count; else byte count if IORF_CHAR_COMMAND set + void* BD_SG_Buffer_Ptr; +} _BlockDev_Scatter_Gather; + +enum BDD_FLAGS { + BDF_Int13_Drive = 0x01, + BDF_Int13_Drive_Bit = 0, + + BDF_Writeable = 0x02, + BDF_Writeable_Bit = 1, + + BDF_Removable = 0x04, + BDF_Removable_Bit = 2, + + BDF_Remote = 0x08, + BDF_Remote_Bit = 3, + + BDF_Serial_Cmd = 0x10, + BDF_Serial_Cmd_Bit = 4, + + BDF_Cache = 0x20, + BDF_Cache_Bit = 5, +}; + +// DCB ================ + +typedef _Packed struct _DCB_COMMON { + uint32_t DCB_physical_dcb; // DCB for physical device + uint32_t DCB_expansion_length; // expansion length; see below + struct DCB_cd_entry *DCB_ptr_cd; // address of calldown list + uint32_t DCB_next_dcb; // link to next DCB + uint32_t DCB_next_logical_dcb; // address of next logical dcb + uint8_t DCB_drive_lttr_equiv; // drive number; see below + uint8_t DCB_unit_number; // drive or unit #; see below + uint16_t DCB_TSD_Flags; // TSD flags; see below + + // Volume Tracking + uint32_t DCB_vrp_ptr; // address of VRP for this DCB + uint32_t DCB_dmd_flags; // demand bits; see below + uint32_t DCB_device_flags; // general purpose flags; see DCB_DEV_FLAGS + uint32_t DCB_device_flags2; // general purpose flags; see DCB_DEV_FLAGS2 + uint32_t DCB_Partition_Start; // partition start sector + uint32_t DCB_track_table_ptr; // address of track table buffer + // for ioctls + uint32_t DCB_bds_ptr; // DOS BDS corresp. to this DCB + // (logical DCB's only) + uint32_t DCB_Reserved1; // reserved; must be zero + uint32_t DCB_Reserved2; // reserved; must be zero + uint8_t DCB_apparent_blk_shift; // log of apparent_blk_size + uint8_t DCB_partition_type; // partition type + uint16_t DCB_sig; // padding and signature + uint8_t DCB_device_type; // device type; see below + uint32_t DCB_Exclusive_VM; // exclusive access handle + uint8_t DCB_disk_bpb_flags; // BPB flags; see below + uint8_t DCB_cAssoc; // # of assoc. logical drives + uint8_t DCB_Sstor_Host; // indicates a sstor host volume + uint16_t DCB_user_drvlet; // userdriveletter settings or 0xff + uint16_t DCB_Reserved3; // reserved; must be zero + uint32_t DCB_Reserved4; // reserved; must be zero +} DCB_COMMON, *PDCB_COMMON; + +typedef _Packed struct _DCB_BLOCKDEV { + uint32_t DCB_BDD_Next; + uint8_t DCB_BDD_BD_Major_Version; // INIT <BDD_BD_Major_Ver> + uint8_t DCB_BDD_BD_Minor_Version; // INIT <BDD_BD_Minor_Ver> + uint8_t DCB_BDD_Device_SubType; + uint8_t DCB_BDD_Int_13h_Number; + uint32_t DCB_BDD_flags; // was BDD_Flags + char * DCB_BDD_Name_Ptr; + + // Apparent geometry as seen by TSD and above + uint64_t DCB_apparent_sector_cnt; // # of sectors + uint32_t DCB_apparent_blk_size; // blk size of device + uint32_t DCB_apparent_head_cnt; // # of heads + uint32_t DCB_apparent_cyl_cnt; // # of cylinders + uint32_t DCB_apparent_spt; // # of secs/trk + + uint32_t DCB_BDD_Sync_Cmd_Proc; + uint32_t DCB_BDD_Command_Proc; + uint32_t DCB_BDD_Hw_Int_Proc; // INIT <0> + uint32_t DCB_BDP_Cmd_Queue_Ascending; + uint32_t DCB_BDP_Cmd_Queue_Descending; + uint32_t DCB_BDP_Current_Flags; + uint32_t DCB_BDP_Int13_Param_Ptr; + uint32_t DCB_BDP_Current_Command; + uint32_t DCB_BDP_Current_Position[2]; + uint32_t DCB_BDP_Reserved[5]; + uint32_t DCB_fastdisk_bdd; // set for DCBs created when a + // fastdisk regs with the + // blockdev BDD for it. Else 0. +} DCB_BLOCKDEV, *PDCB_BLOCKDEV; + + +typedef _Packed struct DCB { + DCB_COMMON DCB_cmn; // common information + uint32_t DCB_max_xfer_len; // maximum transfer length + + // Actual geometry data (as seen below the TSD) + uint64_t DCB_actual_sector_cnt; // number of sectors + uint32_t DCB_actual_blk_size; // actual block size of the device + uint32_t DCB_actual_head_cnt; // number of heads + uint32_t DCB_actual_cyl_cnt; // number of cylinders + uint32_t DCB_actual_spt; // number of sectors per track + + void* DCB_next_ddb_dcb; // link to next DCB on DDB chain + void* DCB_dev_node; // address of dev node for device + uint8_t DCB_bus_type; // Bus type; see below + uint8_t DCB_bus_number; // channel (cable) within adapter + uint8_t DCB_queue_freeze; // queue freeze depth counter + uint8_t DCB_max_sg_elements; // max # s/g elements; see below + + // Volume tracking layer use only + uint8_t DCB_io_pend_count; // # of pending requests for DCB + uint8_t DCB_lock_count; // # of LOCK MEDIA commands + + // SCSI + uint16_t DCB_SCSI_VSD_FLAGS; // Flags for SRB builder + uint8_t DCB_scsi_target_id; // SCSI target ID + uint8_t DCB_scsi_lun; // SCSI logical unit number + uint8_t DCB_scsi_hba; // prot-driver-relative adapter # + uint8_t DCB_max_sense_data_len; // Maximum sense length + uint16_t DCB_srb_ext_size; // miniport srb extension length + + uint8_t DCB_inquiry_flags[8]; // Device inquiry flags + char DCB_vendor_id[8]; // Vendor ID string + char DCB_product_id[16]; // Product ID string + char DCB_rev_level[4]; // Product revision level + char DCB_port_name[8]; // + uint8_t DCB_current_unit; // current unit #; see below + + // Volume tracking layer use only + uint32_t DCB_blocked_iop; // address of requests for an + // inactive volume + + uint32_t DCB_vol_unlock_timer; // unlock timer handle + uint8_t DCB_access_timer; // time measure between accesses + + // Volume tracking layer use only + uint8_t DCB_Vol_Flags; // Volume tracking; see below + + uint8_t DCB_q_algo; // algorithm index; see below + uint8_t DCB_unit_on_ctl; // 0-based device number on ctlr + uint32_t DCB_Port_Specific; // bytes for port driver use + uint32_t DCB_spindown_timer; // timer for drive spin down + + DCB_BLOCKDEV DCB_bdd; +} DCB, *PDCB; + +/** Contains information about a calldown entry. */ +typedef _Packed struct DCB_cd_entry { + IO_callback DCB_cd_io_address; // address of request routine + uint32_t DCB_cd_flags; // demand bits; see below + struct DDB *DCB_cd_ddb; // driver's DDB pointer + struct DCB_cd_entry *DCB_cd_next; // address of next cd entry + uint16_t DCB_cd_expan_off; // offset of expansion area + uint8_t DCB_cd_layer_flags; // flags for layer's use + uint8_t DCB_cd_lgn; // load group number +} DCB_cd_entry, *PDCB_cd_entry; + +enum DCB_BUS { + DCB_BUS_ESDI = 0, + DCB_BUS_SCSI = 1, + DCB_BUS_NEC = 2, + DCB_BUS_SMART = 3, + DCB_BUS_ABIOS = 4 +}; + +enum DCB_TSD_FLAGS { + /** Don't trust the BPB */ + DCB_TSD_INVALID_PARTITION = 1, + /** Bad MBR (physical device only) */ + DCB_TSD_BAD_MBR = 1, + /** User drive letters checked */ + DCB_TSD_USER_LETTERS_CHECKED = (1 << 1), + /** User drive letters checked first time */ + DCB_TSD_FIRST_USER_CHECK = (1 << 2), + /** User set the a drive letter range */ + DCB_TSD_USER_SET = (1 << 4), + /** User int 13 disabled */ + DCB_TSD_NO_USER_INT13 = 0x020, + /** Protmode only int 13 */ + DCB_TSD_PROTMODE_INT_13 = (1 << 6), + /** Reserved drive letter */ + DCB_TSD_NONEXIST_PARTITION = (1 << 7), + /** Recommend BPB set from PBR by TSD (from int 41 or int 46) */ + DCB_TSD_MBPB_PBR = 0x0100, + /** Bit shift for recommended BPB initialized */ + DCB_TSD_RBPB_INIT = (1 << 9), + /** Media BPB initialized */ + DCB_TSD_MBPB_INIT = 0x0400, + /** Apparent set from primary PBR */ + DCB_TSD_APPARENT_PBR = 0x0800, + /** Apparent set from ROM data */ + DCB_TSD_APPARENT_ROM = 0x1000, + /** Actual set from apparent by TSD */ + DCB_TSD_ACTUAL_SET = 0x2000, + /** Actual geometry set prior to TSD */ + DCB_TSD_ACTUAL_PRE_SET = 0x4000, + /** Apparent geometry set prior to TSD */ + DCB_TSD_APPARENT_PRE_SET = 0x8000 +}; + +enum DCB_DEV_FLAGS +{ + /** indicates drive supports spindown command */ + DCB_DEV_SPINDOWN_SUPPORTED_BIT = 31, + DCB_DEV_SPINDOWN_SUPPORTED = (1 << DCB_DEV_SPINDOWN_SUPPORTED_BIT), + + /* indicates drive is currently spun down */ + DCB_DEV_SPUN_DOWN_BIT = 30, + DCB_DEV_SPUN_DOWN = (1 << DCB_DEV_SPUN_DOWN_BIT), + + /* port driver use only - indicates I/O has been received for this DCB */ + + DCB_DEV_IO_ACTIVE_BIT = 29, + DCB_DEV_IO_ACTIVE = (1 << DCB_DEV_IO_ACTIVE_BIT), + + /* this device has been configured as an int 13 drive */ + + DCB_DEV_INT13_CONFIGURED_BIT = 28, + DCB_DEV_INT13_CONFIGURED = (1 << DCB_DEV_INT13_CONFIGURED_BIT), + + /* This DCB cannot handle ASPI or CAM requests */ + + DCB_DEV_NO_ASPICAM_BIT = 27, + DCB_DEV_NO_ASPICAM = (1 << DCB_DEV_NO_ASPICAM_BIT), + + /* this device is going away soon */ + DCB_DEV_REMOVAL_PENDING_BIT = 26, + DCB_DEV_REMOVAL_PENDING = (1 << DCB_DEV_REMOVAL_PENDING_BIT), + + /* logical drives for this int 13 device are controlled by the mapper */ + DCB_DEV_RMM_INT13_BIT = 25, + DCB_DEV_RMM_INT13 = (1 << DCB_DEV_RMM_INT13_BIT), + + /* this device has been processed by a TSD */ + DCB_DEV_TSD_PROCESSED_BIT = 24, + DCB_DEV_TSD_PROCESSED = (1 << DCB_DEV_TSD_PROCESSED_BIT), + + /* this is an equivlaent of IRS_DRV_SINGLE_FLOPPY. This indicates that */ + /* the dmd_a_b_toggling is not set in the floppy dcb. */ + DCB_DEV_SINGLE_FLOPPY = 0x00800000, + + /* this device must be controlled by a real mode driver, and should not */ + /* be taken over in protected mode */ + DCB_DEV_REAL_MODE = 0x00400000, + + /* current queing direction is descending - used by port drivers or IOS if */ + /* DCB_SERIAL_CMD flag is set */ + DCB_DEV_QUE_DESCEND = 0x00200000, + + /* hardware indicated media change */ + DCB_DEV_MEDIA_CHANGED = 0x00100000, + + /* bit indicates the disk geometry has become invalid. */ + DCB_DEV_INVALID_GEOM = 0x00080000, + + /* If this bit is set, it specifies not have the volume tracking layer do + * the 2 second timing stuff for media change. This bit is typically set + * if DCB_DEV_SYNC_MED_CHG_SUPPORT is set. + */ + DCB_DEV_INHIBIT_SW_TIMED_SUPPORT = 0x00040000, /* drive is in read only mode */ + + /* drive has h/w support to indicate by interrupt that disk door has been + * popped open, etc. + */ + DCB_DEV_ASYNC_MED_CHG_SUPPORT = 0x00020000, + + /* drive has h/w sync med. chg supp. -- when u first access a drive with + * media changed, drive returns an error. + */ + DCB_DEV_SYNC_MED_CHG_SUPPORT = 0x00010000, + + DCB_DEV_PHYSICAL = 0x00008000, /* on = physical */ + DCB_DEV_LOGICAL = 0x00004000, /* on = logical */ + DCB_DEV_LOGICAL_BIT = 14, + + DCB_DEV_RMM = 0x00002000, /* on = real mode mapper DCB*/ + DCB_DEV_RMM_BIT = 13, + + DCB_DEV_UNCERTAIN_MEDIA = 0x00001000, /* media may have been changed */ + DCB_DEV_ROM_CFG_REQ = 0x00000800, /* tsd must use rom chain data */ + + DCB_DEV_MUST_CONFIGURE = 0x00000400,/* set at create dcb time */ + /* cleared after all layers */ + /* get the config aep for */ + /* this DCB. */ + + DCB_DEV_SSTOR_VOL = 0x00000200, /* set if this is SSTOR volume */ + + DCB_DEV_PAGING_DEVICE = 0x00000100, /* indicates that the paging drive */ + /* is on this DCB */ + + DCB_CHAR_DEVICE = 0x00000080, /* indicates that this is a char dev*/ + /* + * The foll. DCB_DEV_I13_IN_PROGRESS flag is used in conjunction with RMM + * and the global DCB. This flag is set when an int 13 in progress, in + * iosint13.asm, and cleared when the int 13 is done. + */ + + DCB_DEV_I13_IN_PROGRESS = 0x00000040, + + /** Cached device */ + DCB_DEV_CACHE = 0x00000020 , + /** Serial commands */ + DCB_DEV_SERIAL_CMD = 0x00000010, + /** Remote device */ + DCB_DEV_REMOTE = 0x00000008, + /* Removable media */ + DCB_DEV_REMOVABLE = 0x00000004 , + DCB_DEV_REMOVABLE_BIT = 2, + /** Writeable media */ + DCB_DEV_WRITEABLE = 0x00000002, + /** Int 13h drive */ + DCB_DEV_INT13_DRIVE = 0x00000001, +}; + +enum DCB_DEV2_FLAGS { + DCB_DEV2_THREAD_LOCK = 0x00000001, + DCB_DEV2_THREAD_LOCK_BIT = 0, + + DCB_DEV2_ATAPI_DEVICE = 0x00000002, + DCB_DEV2_ATAPI_DEVICE_BIT = 1, + + DCB_DEV2_DMF_DISK = 0x00000004, /* indicates current media is DMF */ + DCB_DEV2_DMF_DISK_BIT = 2, + + DCB_DEV2_I13_COPY_PROT = 0x00000008,/* indicates int 13 copy protection */ + DCB_DEV2_I13_COPY_PROT_BIT = 3, /* access to one of the floppies */ + + DCB_DEV2_FAIL_FORMAT = 0x00000010, /* indicates that we cannot allow format*/ + DCB_DEV2_FAIL_FORMAT_BIT = 4, + + DCB_DEV2_FLOPTICAL = 0x00000020, /* indicates device is floptical */ + DCB_DEV2_FLOPTICAL_BIT = 5, +}; + +enum DCB_TYPE { + DCB_type_disk = 0x00, /* All Direct Access Devices -- non-removable */ + DCB_type_tape = 0x01, /* Sequencial Access Devices */ + DCB_type_printer = 0x02, /* Printer Device */ + DCB_type_processor = 0x03, /* Processor type device */ + DCB_type_worm = 0x04, /* Write Once Read Many Device */ + DCB_type_cdrom = 0x05, /* CD ROM Device */ + DCB_type_scanner = 0x06, /* Scanner Device */ + DCB_type_optical_memory = 0x07, /* some Optical disk */ + DCB_type_changer = 0x08, /* Changer device e.g. juke box */ + DCB_type_comm = 0x09, /* Communication devices */ + DCB_type_floppy = 0x0A, /* devices like floppy */ + DCB_type_optical_nec = 0x84 /* NEC 5.25" optical disk */ +}; + +enum DCB_dmd_flags { + DCB_dmd_srb_cdb = 0x00000001, /* there must be an srb and cdb for */ + /* each ior. */ + DCB_dmd_rsrv_1 = 0x00000002, /* reserved - must be zero. */ + + DCB_dmd_logical = 0x00000004, /* media address must be logical and*/ + /* dcb must be for a logical device.*/ + + DCB_dmd_physical = 0x00000008, /* media adresses must be physical */ + /* and dcb must be for a physical */ + /* device. */ + + DCB_dmd_small_memory = 0x00000010, /* data buffers must reside in */ + /* in low 16M. */ + + DCB_dmd_rsrv_2 = 0x00000020, /* reserved - must be zero. */ + + DCB_dmd_rsrv_3 = 0x00000040, /* reserved - must be zero. */ + DCB_dmd_rsrv_4 = 0x00000080, /* reserved - must be zero. */ + + DCB_dmd_not_512 = 0x00000100, /* sector size on the media is not */ + /* 512 bytes */ + + DCB_dmd_word_align = 0x00000200, /* data buffers must be word */ + /* aligned. */ + + DCB_dmd_dword_align = 0x00000400, /* data buffers must be double word */ + /* aligned. */ + + DCB_dmd_phys_sgd = 0x00000800, /* scatter/gather descriptors must */ + /* contain physical addresses (they */ + /* will contain linear addresses if */ + /* this demand bit is not set). */ + + DCB_dmd_phys_sgd_ptr = 0x00001000, /* the pointer to the first */ + /* scatter/gather descriptor */ + /* (IOR_sgd_lin_phys) must be a */ + /* physical address (it will be a */ + /* linear addresses if this demand */ + /* bit is not set). */ + + /* If foll. bit set, single floppy drive system -- voltrack needs to do + * the toggling between A: and B: when accesses to made to these drive + * letters. */ + DCB_dmd_do_a_b_toggling = 0x00002000, + + DCB_dmd_query_remov = 0x00004000, /* lower level must be called to */ + /* check if media is removeable/has */ + /* changed. */ + + DCB_dmd_request_sns = 0x00008000, /* port driver cannot perform autosense */ + DCB_dmd_lock_unlock_media = 0x00010000, /* media supports software locking */ + DCB_dmd_load_eject_media = 0x00020000, /* media supports electronic eject */ + DCB_dmd_clear_media_chg = 0x00040000, /* command to clear media change */ + DCB_dmd_serialize_bit = 19, /* layer requires request serialization */ + DCB_dmd_serialize = 1 << DCB_dmd_serialize_bit, + DCB_dmd_prot_mode = 0x00100000, /* override real mode checks for */ + /* this device i.e. ATAPI cdrom */ + DCB_dmd_no_xclusive = 0x00200000, /* indicates exclusive access is */ + /* not required for abs write */ + DCB_dmd_pageability = 0x00400000, /* indicates that access to this volume */ + /* can cause paging */ + + DCB_dmd_rsrv = DCB_dmd_rsrv_1+DCB_dmd_rsrv_2+DCB_dmd_rsrv_3+DCB_dmd_rsrv_4 +}; + + + +// DDB ================ + +typedef _Packed struct DDB { // + uint32_t DDB_phys_addr; // Physical address of ddb + uint32_t DDB_Next_DDB; // next DDB on DVT_DDB chain + uint32_t DDB_Next_DDB_init; // next DDB on DVT_DDB_init chain + uint32_t DDB_dcb_ptr; // address of first DCB owned by this DDB + uint8_t DDB_number_buses; // # of buses supported by the adapter + uint8_t DDB_ios_flags; // IOS flags; see below + uint16_t DDB_sig; // DDB signature; also padding + void* DDB_dvt; // address of this DDB's DVT + void* DDB_devnode_ptr; // address of devnode for device + void* DDB_reserved; // reserved; must be zero +} DDB , *PDDB; + + +// DRP ================ + +typedef _Packed struct DRP { + char DRP_eyecatch_str[8]; // eye catcher string + uint32_t DRP_LGN; // load group number; see below + void* DRP_aer; // addr of asynchronous event routine + struct ILB *DRP_ilb; // address of ILB; see below + char DRP_ascii_name[16]; // driver name; see below + uint8_t DRP_revision; // driver revision + uint32_t DRP_feature_code; // feature code; see below + uint16_t DRP_if_requirements; // I/F requirements; see below + uint8_t DRP_bus_type; // type of I/O bus; see below + uint16_t DRP_reg_result; // registration result; see below + uint32_t DRP_reference_data; // data to pass with AEP_INITIALIZE + uint8_t DRP_reserved1[2]; // reserved + uint32_t DRP_reserved2[1]; // reserved; must be zero +} DRP, *PDRP; + +enum DRP_IF { + DRP_IF_ISA = 0x01, + DRP_IF_EISA = 0x02, + DRP_IF_MCA = 0x04, + DRP_IF_STD = 0xFF +}; + +enum DRP_LGN { + /* Installable File System layer. */ + DRP_FSD = 1 << 0x02, + /** Other port drivers. */ + DRP_MISC_PD = 1 << 0x13 +}; + +enum DRP_reg_result { + /* Driver should remain resident */ + DRP_REMAIN_RESIDENT = 1, + /* Driver should minimize */ + DRP_MINIMIZE = 2, + /* Driver should not load */ + DRP_ABORT = 3, + /* bad layer number - abort driver */ + DRP_INVALID_LAYER = 4 +}; + + +// ILB ================== + +typedef _Packed struct ILB { + /* service routine */ + void __cdecl (*ILB_service)(struct ISP *pisp); + void __cdecl (*ILB_dprintf)(const char *format, ...); + /** waits for 1/10 seconds. */ + void __cdecl (*ILB_Wait_10th_Sec)(void); + void* ILB_internal_request; // addr of request routine + void* ILB_io_criteria_rtn; // addr of IOR criteria routine + void* ILB_int_io_criteria_rtn; // addr of IOP criteria routine + uint32_t ILB_dvt; // offset to addr of driver's DVT + uint32_t ILB_ios_mem_virt; // addr of IOS memory pool + void __cdecl (*ILB_enqueue_iop)(struct IOP *iop, struct DCB *dcb); + struct IOP * __cdecl (*ILB_dequeue_iop)(struct DCB *dcb); + uint32_t ILB_reserved_1; // reserved; must be zero + uint32_t ILB_reserved_2; // reserved; must be zero + uint16_t ILB_flags; // flags + uint8_t ILB_driver_numb; // number of calls to AEP_INITIALIZE + uint8_t ILB_reserved_3; // reserved; must be zero +} ILB, *PILB; + +// IOR ================= + +typedef _Packed struct type_sdeffsd_req_usage { /* */ + uint16_t _IOR_ioctl_drive; + uint16_t _IOR_ioctl_function ; + uint32_t _IOR_ioctl_control_param ; + uint32_t _IOR_ioctl_buffer_ptr; + uint32_t _IOR_ioctl_client_params; + uint32_t _IOR_ioctl_return; +} _type_sdeffsd_req_usage; + +typedef _Packed union urequestor_usage { /* */ + uint32_t _IOR_requestor_usage[5]; + struct type_sdeffsd_req_usage sdeffsd_req_usage; +} _urequestor_usage; + +typedef void (* CMDCPLT)(void); + +typedef _Packed struct _IOR { + uint32_t IOR_next; // client link; see below + uint16_t IOR_func; // function; see below + uint16_t IOR_status; // request status; see below + uint32_t IOR_flags; // request flags; see below + CMDCPLT IOR_callback; // address of callback; see below + uint64_t IOR_start_addr; // starting address; see below + uint32_t IOR_xfer_count; // # of sectors/bytes; see below + void* IOR_buffer_ptr; // client buffer; see below + uint32_t IOR_private_client; // BlockDev/IOS client reserved + uint32_t IOR_private_IOS; // reserved space for IOS + uint32_t IOR_private_port; // private area for port driver + union urequestor_usage _ureq; // requestor usage; see below + uint32_t IOR_req_req_handle; // request handle; see below + uint32_t IOR_req_vol_handle; // media handle; see below + uint32_t IOR_sgd_lin_phys; // first physical SGD; see below + uint8_t IOR_num_sgds; // number of physical SGDs + uint8_t IOR_vol_designtr; // drive letter; see below + uint16_t IOR_ios_private_1; // reserved by IOS to force alignment + uint32_t IOR_reserved_2[2]; // reserved for internal use +} IOR, *PIOR; + +/** command codes for IOR_func as defined above */ +enum IOR_funcs { + /* + ** IOR_READ + ** + ** Function: + ** + ** Reads the # of sectors/bytes as specified in IOR_xfer_count. + ** See PDK documentation for specifics of parameter setting. + ** + ** + ** Notes: + ** + */ + + IOR_READ = 0x00, + + /* + ** IOR_WRITE + ** + ** Function: + ** + ** Writes the # of sectors/bytes as specified in IOR_xfer_count. + ** See PDK documentation for specifics of parameter setting. + ** + ** Notes: + ** + */ + + IOR_WRITE = 0x01, + + /* + ** IOR_VERIFY + ** + ** Function: + ** + ** Verifies the # of sectors/bytes as specified in IOR_xfer_count. + ** + ** Notes: + ** + */ + + IOR_VERIFY = 0x02, /* verify data on device */ + + /* + ** IOR_CANCEL + ** + ** Function: + ** + ** Cancels the IOR referenced in ... + ** + ** Notes: + ** + ** Currently not supported in Chicago + ** + */ + + IOR_CANCEL = 0x03, + + /* + ** IOR_WRITEV + ** + ** Function: + ** + ** Writes and verifies the # of sectors/bytes as specified in IOR_xfer_count. + ** + ** Notes: + ** + ** Some hardware (IDE, for example) does not support this function. + ** + */ + + IOR_WRITEV = 0x04, + + /* + ** IOR_MEDIA_CHECK + ** + ** Function: + ** + ** Checks to see if media has changed, and returns status in IOR_status. + ** + ** Notes: + ** + ** Obsolete. Use MEDIA_CHECK_RESET below + ** + */ + + IOR_MEDIA_CHECK = 0x05, + + /* + ** IOR_MEDIA_CHECK_RESET + ** + ** Function: + ** + ** Checks to see if media has changed, and returns status in IOR_status. + ** + ** Notes: + ** + */ + + IOR_MEDIA_CHECK_RESET = 0x06, + + /* + ** IOR_LOAD_MEDIA + ** + ** Function: + ** + ** Performs a LOAD MEDIA operation on removable drives. + ** + ** Notes: + ** + */ + + IOR_LOAD_MEDIA = 0x07, + + /* + ** IOR_EJECT_MEDIA + ** + ** Function: + ** + ** Performs an EJECT MEDIA operation on removable drives. + ** + ** Notes: + ** + ** For disk and CD-ROM devices, applications are queried before eject, + ** and the lock count is checked for zero. If one of these checks fails, + ** the user is queried to see if he wants to proceed. + */ + + IOR_EJECT_MEDIA = 0x08, + + /* + ** IOR_LOCK_MEDIA + ** + ** Function: + ** + ** Performs a LOCK MEDIA operation on removable drives. + ** + ** Notes: + ** + ** LOCK and UNLOCK MEDIA calls must be synchronized, as a depth counter is + ** maintained by IOS. + */ + + IOR_LOCK_MEDIA = 0x09, + + /* + ** IOR_UNLOCK_MEDIA + ** + ** Function: + ** + ** Performs an UNLOCK MEDIA operation on removable drives. + ** + ** Notes: + ** + ** LOCK and UNLOCK MEDIA calls must be synchronized, as a depth counter is + ** maintained by IOS. UNLOCK MEDIA is delayed by about 5 seconds. + */ + + IOR_UNLOCK_MEDIA = 0x0A, + + /* + ** IOR_REQUEST_SENSE + ** + ** Function: + ** + ** Performs an REQUEST SENSE operation on removable drives. + ** + ** Notes: + ** + ** Currently supported for SCSI devices only. + ** + */ + + IOR_REQUEST_SENSE = 0x0B, + + /* + ** IOR_COMPUTE_GEOM + ** + ** Function: + ** + ** Results in a reexamination of volume and device characteristics. + ** + ** Notes: + ** + ** When this command is received, each IOS layer assumes the device has + ** changed, and performs whatever initialization required. For example, + ** the disk TSD will reexamine the partitions of a device. + ** + */ + + IOR_COMPUTE_GEOM = 0x0C, + + /* + ** IOR_GEN_IOCTL + ** + ** Function: + ** + ** Function permits device-specific IOCtl's to be issued to IOS drivers. + ** Also supports standard Int 21 function 44xx DOS IOCtl's. See CDIOCTL.H + ** for examples of CD IOCtl's. + ** + ** aliasing for fields used by IOCTL's - + ** this section gives both the normal and IOCTL names for the fields + ** + ** IOR_ioctl_drive - BX from 16 bit IOCTL - usually a 1 based drive number + ** IOR_ioctl_function - AX from 16 bit IOCTL + ** IOR_ioctl_handle - useful handle? or original? + ** IOR_ioctl_control_param - CX zero extended to ULONG + ** IOR_ioctl_buffer_ptr - DS:DX mapped flat general buffer from the IOCTL + ** IOR_ioctl_client_params - a pointer to the parameters passed in from + ** the calling application the IORF_16BIT_IOCTL flag must be used to + ** determine the structure type. If it is a 16 bit IOCTL, the pointer + ** will be to the CLIENT_REGS structure. 32 bit is as of yet undef'ed + ** IOR_ioctl_return - return value to be mapped to the IOCTL caller on exit + ** IOR_ioctl_buffer_length - size of buffer pointed to by + ** IOR_ioctl_buffer_ptr (not used by int 21 440d IOCTL calls) + ** + ** Notes: + ** + */ + + IOR_GEN_IOCTL = 0x0D, + + /* + ** IOR_FORMAT + ** + ** Function: + ** + ** Allows issuance of a low level format packet as defined in the int 13 + ** specification. + ** + ** Notes: + ** + ** IOR_format_address_field => low level sector map + ** See IOP.H IOP_FORMAT_XXX fields for additional information. + */ + + IOR_FORMAT = 0x0E, + + /* + ** IOR_SCSI_PASS_THROUGH + ** + ** Function: + ** + ** Each layer passes this request down with modification to the SCSI port + ** driver. + ** + ** Notes: + ** + ** The IOR must contain a pointer to a valid SRB. Also, "ebx" must point + ** to the BDD portion of the DCB when IOS_SendCommand is called with a + ** passthrough request. + */ + + IOR_SCSI_PASS_THROUGH = 0x0F, + + /* + ** IOR_CLEAR_QUEUE + ** + ** Function: + ** + ** Callback of request indicates all requests issued prior to this request + ** have been completed. + ** + ** Notes: + */ + + IOR_CLEAR_QUEUE = 0x10, + + /* + ** IOR_DOS_RESET + ** + ** Function: + ** + ** Issued in response to an int 13 reset by the int 13 vxd + ** + ** Notes: + ** + ** Currently used only by and for the IOS floppy driver. + */ + + IOR_DOS_RESET = 0x11, + + /* + ** IOR_SCSI_REQUEST + ** + ** Function: + ** + ** generic function that indicates the request is for SCSI. + ** + ** Notes: + ** + ** SRB field in IOR must be valid. Normally used by IOS layers to send + ** internal requests to SCSI devices. + */ + + IOR_SCSI_REQUEST = 0x12, + + /* + ** IOR_SET_WRITE_STATUS + ** + ** Function: + ** + ** results in the correct setting of DCB_DEV_WRITABLE flag in the DCB if + ** SUCCESS status is returned. + ** + ** Notes: + ** + ** Currently only supported by the IOS floppy driver. + */ + + IOR_SET_WRITE_STATUS = 0x22, + + /* + ** IOR_RESTART_QUEUE + ** + ** Function: + ** + ** "Placeholder" function that results in restarting of the queue provided + ** by the IOS queuing services. Has no other effect. + ** + ** Notes: + ** + ** Should be sent after the DCB_QUEUE_FREEZE field has been decremented to + ** zero. + */ + + IOR_RESTART_QUEUE = 0x23, + + /* + ** IOR_ABORT_QUEUE + ** + ** Function: + ** + ** Causes each layer to call back each queued request with status of + ** IORS_CANCELED + ** + ** Notes: + ** + */ + + IOR_ABORT_QUEUE = 0x24, + + /* + ** IOR_SPIN_DOWN + ** + ** Function: + ** + ** Causes the specified drive to be spun down. + ** + ** Notes: + ** + */ + + IOR_SPIN_DOWN = 0x25, + + /* + ** IOR_SPIN_UP + ** + ** Function: + ** + ** Causes the specified drive to be spun up. + ** + ** Notes: + ** + */ + + IOR_SPIN_UP = 0x26, + + /* + ** IOR_FLUSH_DRIVE + ** + ** Function: + ** + ** Causes layer drivers to flush out dirty data. + ** + ** Notes: + ** + ** This is a synchronous function and should not be called at + ** event/interrupt time. + ** + */ + + IOR_FLUSH_DRIVE = 0x27, + + + /* + ** IOR_FLUSH_DRIVE_AND_DISCARD + ** + ** Function: + ** + ** Causes layer drivers to flush out dirty data and then dicard cached + ** data. + ** + ** Notes: + ** + ** This is a synchronous function and should not be called at + ** event/interrupt time. + ** + */ + + IOR_FLUSH_DRIVE_AND_DISCARD = 0x28, + + + /* + ** IOR_FSD_EXT + ** + ** Function: + ** + ** Sends private command from an IOS client to the FSD extension + ** layer (DRP_FSD_EXT_1 or DRP_FSD_EXT_2) such as a Compressed + ** Volume Manager (CVM). + ** + ** Notes: + ** + ** This call is similar in intent and usage to IOR_GEN_IOCTL; + ** however, it can be used in the swapper path, so, in general, + ** the handling driver should not touch pageable code or data. + ** + */ + + IOR_FSD_EXT = 0x29, + + /* + ** IOR_FLOPTICAL_MODE_SENSE + ** + ** Function: + ** + ** Issues MODE SENSE command to page 0x2e, as is required to indicate to the + ** floptical that it is supported. + ** + ** Notes: + ** + ** Don't use this command, as it is used by the system. + ** + */ + + IOR_FLOPTICAL_MODE_SENSE = 0x2A, + +}; + +/** IOR status codes for IOR_status */ + +enum IOR_STATUS { + IORS_SUCCESS = 0x00, /* command completed successfully */ + + IORS_SUCCESS_WITH_RETRY = 0x01, /* successful, but retries required */ + + IORS_SUCCESS_WITH_ECC = 0x02, /* ditto, but with ECC */ + + IORS_INVALID_SECTOR = 0x10, /* old blockdev error code for */ + /* requests on an invalid sector */ + /* number */ + IORS_CANCELED = 0x11, /* command was canceled */ + + IORS_CMD_IN_PROGRESS = 0x12, /* command is in progress, and can't be canceled */ + + IORS_INVALID_CMD_PTR = 0x13, /* cancel of an invalid command */ + + IORS_MEDIA_ERROR = 0x14, /* media failure */ + + IORS_DEVICE_ERROR = 0x15, /* error on recalib. drive, etc. */ + + IORS_INVALID_COMMAND = 0x16, /* Command not supported or invalid */ + + IORS_NO_DEVICE = 0x17, /* physical or logical device nonexistant */ + + IORS_NO_MEDIA = 0x18, /* media removed from device */ + + IORS_UNCERTAIN_MEDIA = 0x19, /* media may have changed */ + + IORS_UNREC_ERROR = 0x1A, /* un-recoverable error */ + + IORS_HW_FAILURE = 0x1B, /* general hardware failure */ + + IORS_UNFORMATTED_MEDIA = 0x1C, /* unformatted media */ + + IORS_MEMORY_ERROR = 0x1D, /* error allocating DMA buffer space for I/O */ + + IORS_TIME_OUT = 0x1E, /* device timed out */ + + IORS_WRITE_PROTECT = 0x1F, /* write protect error */ + + IORS_NOT_READY = 0x20, /* device not ready */ + + IORS_BUSY = 0x21, /* device is busy */ + + IORS_VOL_NOT_LOCKED = 0x22, /* volume received unlock without lk*/ + + IORS_VOL_LOCKED = 0x23, /* eject received with drive locked */ + + IORS_VOL_NOT_REMOVABLE = 0x24, /* removable request to non-remov drive */ + + IORS_VOL_IN_USE = 0x25, /* volume is in use - used for eject*/ + + IORS_LOCK_COUNT_EXCEEDED = 0x26, /* volume lock count exceeded */ + + IORS_VALID_EJECT_FAILED = 0x27, /* eject command was not accepted */ + + IORS_ILLEGAL_ACCESS_MODE = 0x28, /* cdrom read on audio or attempt */ + /* play on data */ + + IORS_LOCK_VIOLATION = 0x29, /* illegal access to locked device */ + + IORS_WRONG_MEDIA = 0x2a, /* wrong media in drive */ + + IORS_OUT_OF_SPACE = 0x2b, /* no space on media */ + + IORS_BIG_IO_BREAKUP_FAILED = 0x2c,/* attempt to split big I/O barfed */ + + IORS_ERROR_DESIGNTR = 0x10, /* bit indicating error occurred */ + + IORS_INVALID_PARM = IORS_ERROR_DESIGNTR, /* bit indicating error occurred */ +}; + +enum IOR_FLAGS { + + IORF_HIGH_PRIORITY_BIT=0, /* binary priority indication */ + IORF_HIGH_PRIORITY = (1 << IORF_HIGH_PRIORITY_BIT), /* 0x0001 */ + + IORF_SCATTER_GATHER_BIT=1, /* bit indicating BDCB physical SGD */ + /* list present */ + IORF_SCATTER_GATHER = (1 << IORF_SCATTER_GATHER_BIT), /* 0x0002 */ + + IORF_DONT_CACHE_BIT=2, /* bit indicating that the BDCB data*/ + /* should not be cached */ + IORF_DONT_CACHE = (1 << IORF_DONT_CACHE_BIT), /* 0x0004 */ + + IORF_BYPASS_VOLTRK=0x0008, /* request will not be volume trked */ + IORF_BYPASS_VOLTRK_BIT=3, + + IORF_16BIT_IOCTL=0x0010, /* if true, 16 bit IOCTL calling */ + /* app, else 32 bit ioctl */ + IORF_16BIT_IOCTL_BIT=4, + + IORF_SWAPPER_IO=0x0020, /* request is from the swapper */ + IORF_SWAPPER_IO_BIT=5, + + IORF_DOUBLE_BUFFER=0x0040, /* indicates that the request is to */ + /* be completed via double */ + /* buffering. client must */ + /* ensure that both the sgd buffer */ + /* pointers and IOR_sgd_lin_phys */ + /* are virtual pointers. */ + IORF_DOUBLE_BUFFER_BIT=6, + + IORF_SYNC_CMD_DONE=0x0080, /* used by IOS only to indicate */ + /* completion */ + /* of synchronous command */ + IORF_SYNC_CMD_DONE_BIT=7, + + IORF_SYNC_COMMAND=0x0100, /* indicates synchronous command */ + /* (complete before return from IOS */ + IORF_SYNC_COMMAND_BIT=8, + + IORF_CHAR_COMMAND=0x0200, /* indicates transfer counts and */ + /* scatter/gather buffer sizes are */ + /* byte values */ + IORF_CHAR_COMMAND_BIT=9, + + IORF_VERSION_002=0x0400, /* indicates use of extended BCB */ + /* (IOR) format for request */ + IORF_VERSION_002_BIT=10, + + IORF_BYPASS_QUEUE=0x0800, /* request should bypass IOS queuing*/ + /* internal IOS driver use only */ + IORF_BYPASS_QUEUE_BIT=11, + + IORF_BLOCKDEV_EMULATE=0x1000, /* this request started as a BCB */ + IORF_BLOCKDEV_EMULATE_BIT=12, + + IORF_POSTPONED_VOL_OPS=0x2000, + IORF_POSTPONED_VOL_OPS_BIT=13, + + IORF_INHIBIT_GEOM_RECOMPUTE=0x4000, + IORF_INHIBIT_GEOM_RECOMPUTE_BIT=14, + /* force inhibit of device geometry */ + /* recomputation. */ + + IORF_SRB_VALID=0x8000, /* indicates that IOP_srb points to */ + IORF_SRB_VALID_BIT=15, /* a valid SRB */ + + IORF_BYPASS_A_B=0x10000, /* indicates that VOLTRK should */ + IOFR_BYPASS_A_B_BIT=16, /* bypass AB check */ + + IORF_QUIET_VOLTRK=0x20000, /* indicates that volume tracking */ + IORF_QUIET_VOLTRL_BIT=17, /* just return error when wrong */ + /* media in drive (no dialog box) */ + + IORF_AUDIO_DATA_READ=0x40000, /* indicates an audio data read */ + IORF_AUDIO_DATA_READ_BIT=18, + + IORF_LOGICAL_START_SECTOR=0x80000, + IORF_LOGICAL_START_SECTOR_BIT=19, + /* IOR_start_addr is logical */ + + IORF_PARTITION_BIAS_ADDED=0x100000, + IORF_PARTITION_BIAS_ADDED_BIT=20, /* set by TSD only to indicate that */ + /* it has added in the bias, as req'd */ + /* by IORF_LOGICAL_START_SECTOR */ + + IORF_DATA_IN_BIT=21, /* indicates a data read operation */ + IORF_DATA_IN = (1 << IORF_DATA_IN_BIT), + + IORF_DATA_OUT_BIT=22, /* indicates a data write operation */ + IORF_DATA_OUT = (1 << IORF_DATA_OUT_BIT), + + IORF_VOL_RETRY_BIT=23, /* indicates volume tracking retried*/ + IORF_VOL_RETRY = (1 << IORF_VOL_RETRY_BIT), + /* request (internal use only) */ + + IORF_NO_COMPRESS_BIT=24, /* do not compress data */ + IORF_NO_COMPRESS = (1 << IORF_NO_COMPRESS_BIT), + + IORF_DIRECT_IO_BIT=25, /* E.g., INT 25h or INT 26h */ + IORF_DIRECT_IO = (1 << IORF_DIRECT_IO_BIT), + + IORF_PHYS_SGDS_BIT=26, + IORF_PHYS_SGDS = (1 << IORF_PHYS_SGDS_BIT), + /* indicates IOR_sgd_lin_phys valid */ + + IORF_IO_TOO_BIG_BIT=27, + IORF_IO_TOO_BIG = (1 << IORF_IO_TOO_BIG_BIT), + /* indicates I/O is too big for */ + /* single pass (set by IOS criteria*/ + /* code). */ + IORF_WIN32_BIT=28, + IORF_WIN32 = (1 << IORF_WIN32_BIT), + /* indicates I/O is from 32 bit API */ + IORF_CHAR_DEVICE_BIT=29, + IORF_CHAR_DEVICE = (1 << IORF_CHAR_DEVICE_BIT), + + IORF_PHYS_CMD_BIT=30, /* indicates I/O is for a physical */ + /* device */ + IORF_PHYS_CMD = (1 << IORF_PHYS_CMD_BIT), + + IORF_IDE_RESERVED_BIT=31, /* indicates I/O is for a physical */ + /* device */ + IORF_IDE_RESERVED = (1 << IORF_IDE_RESERVED_BIT) + +}; + +// IOP ================= + +#define IOP_CALLBACK_TABLE_DEPTH 6 + +typedef _Packed struct IOP_callback_entry { + IO_callback IOP_CB_address; /* call back address */ + uint32_t IOP_CB_ref_data; /* pointer to callback ref data */ +} IOP_callback_entry; + +typedef _Packed struct IOP { + uint32_t IOP_physical; // physical address of IOP + struct DCB *IOP_physical_dcb; // address of physical DCB + struct DCB *IOP_original_dcb; // address of DCB designated by IOR + uint16_t IOP_timer; // Request Control Block (RCB) current + // timeout value + uint16_t IOP_timer_orig; // original timeout value + DCB_cd_entry* IOP_calldown_ptr; // address of next calldown routine + IOP_callback_entry* IOP_callback_ptr; // address of current callback address + uint32_t IOP_voltrk_private; // for use by volume tracking + uint32_t IOP_Thread_Handle; // handle of thread originating + // the I/O request + uint32_t IOP_srb; // used by SCSI'izers to pass SRB + // address to next layer + uint32_t IOP_reserved[2]; // reserved; must be zero + IOP_callback_entry IOP_callback_table[IOP_CALLBACK_TABLE_DEPTH]; + // RCB_CallBackTable + uint8_t IOP_format_head; // low level format data + uint8_t IOP_format_xfer_rate; + uint16_t IOP_format_track; + uint32_t IOP_format_num_sectors; + IOR IOP_ior; // I/O request descriptor +} IOP, *PIOP; + +/** Let lower levels continue processing this IOP. */ +static void IopCalldown(IOP* iop) { + // Get who is supposed to be next driver in the chain + iop->IOP_calldown_ptr = iop->IOP_calldown_ptr->DCB_cd_next; + // Call it + iop->IOP_calldown_ptr->DCB_cd_io_address(iop); +} + +/** Finish processing this IOP, and call back previous levels. */ +static void IopCallback(IOP* iop) { + iop->IOP_callback_ptr -= 1; + iop->IOP_callback_ptr->IOP_CB_address(iop); +} + +// ISP ================= + +typedef uint16_t IspResult; // unspecified error codes, but zero = no error + +typedef _Packed struct ISP { + uint16_t ISP_func; // function to be performed; see below + IspResult ISP_result; // result: zero = no error +} ISP, *PISP; + +enum ISP_funcs { + /* create ddb */ + ISP_CREATE_DDB = 0, + /* create dcb (Physical) */ + ISP_CREATE_DCB = 1, + /* create iop */ + ISP_CREATE_IOP = 2, + /* allocate memory */ + ISP_ALLOC_MEM = 3, + /* deallocate memory */ + ISP_DEALLOC_MEM = 4, + /** insert entry in calldown table */ + ISP_INSERT_CALLDOWN = 5, + /* associate dcb & relative drive # */ + ISP_ASSOCIATE_DCB = 6, + /* return DCB for logical volume */ + ISP_GET_DCB = 7, + /** get first/next DCB */ + ISP_GET_FIRST_NEXT_DCB = 8, + /* deallocate DDB */ + ISP_DEALLOC_DDB = 9, + /* destroy DCB */ + ISP_DESTROY_DCB = 10, + /* ask for logical-to-physical info */ + ISP_QUERY_MATCHING_DCBS = 11, + /* ask if we can remove a device */ + ISP_QUERY_REMOVE_DCB = 12, + /* indicate that a device has been removed */ + ISP_DEVICE_REMOVED = 13, + /* indicate that a device has arrived */ + ISP_DEVICE_ARRIVED = 14, + /* disassociate dcb & drive # */ + ISP_DISASSOCIATE_DCB = 15, + /* pick a drive letter */ + ISP_DRIVE_LETTER_PICK = 16, + /* read registry */ + ISP_REGISTRY_READ = 17, + /* find LDM entry */ + ISP_FIND_LDM_ENTRY = 18, + /* delete LDM entry */ + ISP_DELETE_LDM_ENTRY = 19, + /* broadcast an AEP from a driver */ + ISP_BROADCAST_AEP = 20 +}; + +typedef _Packed struct ISP_dcb_create { // + ISP ISP_dcb_hdr; // Standard header + uint16_t ISP_dcb_size; // size of DCB to create, in bytes + uint32_t ISP_dcb_ptr; // address of DCB + uint8_t ISP_pad1[2]; // Pad to DWORD boundary +} ISP_dcb_create, *PISP_dcb_create; + +static PDCB IspCreateDcb(ILB* ilb, uint16_t size) { + ISP_dcb_create isp = {{ISP_CREATE_DCB}}; + isp.ISP_dcb_size = size; + ilb->ILB_service((PISP)&isp); + return isp.ISP_dcb_hdr.ISP_result != 0 ? NULL : (PDCB) isp.ISP_dcb_ptr; +} + +typedef _Packed struct ISP_ddb_create { // + ISP ISP_ddb_hdr; // Standard header + uint16_t ISP_ddb_size; // size of DDB to create, in bytes + uint32_t ISP_ddb_ptr; // address of DDB + uint8_t ISP_ddb_flags; // flags; see below + uint8_t ISP_pad0[1]; // Pad to DWORD boundary +} ISP_ddb_create, *PISP_ddb_create; + +static PDDB IspCreateDdb(ILB* ilb, uint16_t size) { + ISP_ddb_create isp = {{ISP_CREATE_DDB}}; + isp.ISP_ddb_size = size; + ilb->ILB_service((PISP)&isp); + return isp.ISP_ddb_hdr.ISP_result != 0 ? NULL : (PDDB) isp.ISP_ddb_ptr; +} + +typedef _Packed struct ISP_calldown_insert { + ISP ISP_i_cd_hdr; // Standard header + uint32_t ISP_i_cd_dcb; // address of DCB + void* ISP_i_cd_req; // address of request routine + uint32_t ISP_i_cd_ddb; // address of DDB + uint16_t ISP_i_cd_expan_len; // size of IOP expansion required by this driver + uint32_t ISP_i_cd_flags; // demand flags + uint8_t ISP_i_cd_lgn; // load group number; typically same as AEP_lgn + uint8_t ISP_pad4[1]; // Pad to DWORD boundary +} ISP_calldown_insert, *PISP_calldown_insert; + +static IspResult IspInsertCalldown(ILB* ilb, PDCB dcb, void (*calldown)(PIOP), PDDB ddb, uint16_t expand_len, uint32_t flags, uint8_t lgn) { + ISP_calldown_insert isp = {{ISP_INSERT_CALLDOWN}}; + isp.ISP_i_cd_dcb = (uint32_t) dcb; + isp.ISP_i_cd_req = calldown; + isp.ISP_i_cd_ddb = (uint32_t) ddb; + isp.ISP_i_cd_expan_len = expand_len; + isp.ISP_i_cd_flags = flags; + isp.ISP_i_cd_lgn = lgn; + ilb->ILB_service((PISP)&isp); + return isp.ISP_i_cd_hdr.ISP_result; +} + +typedef _Packed struct ISP_AEP_BROADCAST { + ISP ISP_baep_hdr; // Standard header + void* ISP_baep_paep; // address of AEP to broadcast +} ISP_AEP_BROADCAST,*PISP_AEP_BROADCAST; + +static IspResult IspBroadcastAep(ILB* ilb, PAEP paep) { + ISP_AEP_BROADCAST isp = {{ISP_BROADCAST_AEP}}; + isp.ISP_baep_paep = paep; + ilb->ILB_service((PISP)&isp); + return isp.ISP_baep_hdr.ISP_result; +} + +// SGD ========= + +typedef struct _SGD { + uint32_t SG_buff_ptr; // address of data buffer; see below + uint32_t SG_buff_size; // number of bytes to transfer +} SGD, *PSGD; + +#endif // IOS_H |
