www.pudn.com > SMSC USB2.0.zip > protocol.h
/*============================================================================
____________________________________________________________________________
______________________________________________
SSSS M M CCCC Standard Microsystems Corporation
S MM MM SSSS C Austin Design Center
SSS M M M S C 11000 N. Mopac Expressway
S M M SSS C Stonelake Bldg. 6, Suite 500
SSSS M M S CCCC Austin, Texas 78759
SSSS ______________________________________________
____________________________________________________________________________
Copyright(C) 1999, Standard Microsystems Corporation
All Rights Reserved.
This program code listing is proprietary to SMSC and may not be copied,
distributed, or used without a license to do so. Such license may have
Limited or Restricted Rights. Please refer to the license for further
clarification.
____________________________________________________________________________
Notice: The program contained in this listing is a proprietary trade
secret of SMSC, Hauppauge, New York, and is copyrighted
under the United States Copyright Act of 1976 as an unpublished work,
pursuant to Section 104 and Section 408 of Title XVII of the United
States code. Unauthorized copying, adaption, distribution, use, or
display is prohibited by this law.
____________________________________________________________________________
Use, duplication, or disclosure by the Government is subject to
restrictions as set forth in subparagraph(c)(1)(ii) of the Rights
in Technical Data and Computer Software clause at DFARS 52.227-7013.
Contractor/Manufacturer is Standard Microsystems Corporation,
80 Arkay Drive, Hauppauge, New York, 1178-8847.
____________________________________________________________________________
____________________________________________________________________________
-
____________________________________________________________________________
comments tbd
____________________________________________________________________________
Revision History
Date Who Comment
________ ___ _____________________________________________________________
12/06/01 tbh initial version
01/15/02 cds added s_scsi_cb structure, added read_format_capacity and
start_stop_unit command parameter structures to the scsi cb
union. Hopefully these unions will grow where they are used
(see lun.c for code examples utilizing structure)
04/17/02 tbh added k_protocol_mode_sense_6
07/23/02 baw added password protocol constants
07/25/02 baw Added three more password commands, they are
- Password Supported
- Is Locked
- Is Password Validated
These commands will give the application access to more information
so it doesn't have to make assuptions based on media present.
09/25/02 cds added new vendor specific command: erase_media and report_media_geometry
10/01/02 ds Added two new command definitions to support the vendor specific commands
secure_memory_write and secure_memory_read on a nvstore. Per a customer's requirement
============================================================================*/
//------------------------------------------------------------------------------
#define k_protocol_format_unit 0x04
#define k_protocol_inquiry 0x12
#define k_protocol_mode_select_10 0x55
#define k_protocol_mode_sense_10 0x5A
#define k_protocol_mode_sense_6 0x1A
#define k_protocol_prevent_allow_medium_remval 0x1E
#define k_protocol_read_10 0x28
#define k_protocol_read_12 0xA8
#define k_protocol_read_capacity 0x25
#define k_protocol_read_format_capacities 0x23
#define k_protocol_request_sense 0x03
#define k_protocol_start_stop_unit 0x1B
#define k_protocol_synchronize_cache 0x35
#define k_protocol_test_unit_ready 0x00
#define k_protocol_verify_10 0x2F
#define k_protocol_write_10 0x2A
#define k_protocol_write_12 0xAA
#define k_protocol_write_verify 0x2E
//Vendor specific opcode for secure-memory in nvstore
#define k_protocol_vendor_secure_memory_read 0xFA
#define k_protocol_vendor_secure_memory_write 0xFB
// The following vendor command has been made up,
// it is not a standard SCSI command.
// I don't believe the code conflicts with anything presently.
// hopefully as the standard evolves it will continue not to conflict
#define k_protocol_vendor 0xCF //not a standard SCSI command
//------------------------------------------------------------------------------
// vendor commands, cdb[1]
#define k_vendor_erase_media 0x10
#define k_vendor_report_media_geometry 0x11
//------------------------------------------------------------------------------
// verify
#define kbm_verify_opt_dpo 0x10
#define kbm_verify_opt_bytchk 0x02
#define kbm_verify_opt_reladr 0x01
typedef struct s_param_verify10
{
uint8 opts;
t_udw32 lba;
uint8 reserved1;
t_uw16 len;
uint8 control;
} t_param_verify10;
typedef struct s_param_verify12
{
uint8 opts;
t_udw32 lba;
t_udw32 len;
uint8 control;
} t_param_verify12;
typedef union u_param_verify
{
t_param_verify10 verify10;
t_param_verify12 verify12;
} t_param_verify;
//------------------------------------------------------------------------------
// Read10 / Read12
#define kbm_rwopts_dpo 0x10 // cache control bit
#define kbm_rwopts_fua 0x08 // force unit access
#define kbm_rwopts_reladr 0x01 // relative addressing
typedef struct s_param_rw10
{
uint8 opts;
t_udw32 lba;
uint8 rsvd1;
t_uw16 len;
uint8 control;
} t_param_rw10;
typedef struct s_param_rw12
{
uint8 opts;
t_udw32 lba;
t_udw32 len;
uint8 control;
} t_param_rw12;
typedef union u_param_read
{
t_param_rw10 rw10;
t_param_rw12 rw12;
} t_param_rw;
//------------------------------------------------------------------------------
// read format capacity
typedef struct s_capacity
{
t_udw32 lba_max; // max lba that can be accessed.
t_udw32 lba_sz; // size of a single logical block, in bytes
} t_capacity;
typedef struct s_param_read_format_capacity
{
uint8 reserved[6] ;
uint16 allocation_len ;
uint8 control ;
} t_param_read_format_capacity ;
typedef struct s_capacity_list_hdr
{
uint8 reserved[3];
uint8 capacity_list_length;
} t_capacity_list_hdr ;
typedef struct s_format_capacity_dscr
{
t_udw32 num_blocks ;
uint8 descr_or_format_type ;
uint8 max_block_sz_hi;
t_uw16 max_block_sz_lo;
} t_format_capacity_dscr ;
#if 0
#define k_max_fmt_cap_entry 4
typedef struct s_fmt_cap_dscr
{
t_fmt_cap_hdr fmt_cap_hdr;
t_fmt_cap_entry fmt_cap_entry[k_max_fmt_cap_entry];
} t_fmt_cap_dscr;
#endif
//------------------------------------------------------------------------------
// mode sense, mode select
#define kbm_mode_sense_dbd 0x80
#define kbm_mode_sense_pc 0xc0
#define k_mode_sense_pc_current 0x00
#define k_mode_sense_pc_changable 0x40
#define k_mode_sense_pc_default 0x80
#define k_mode_sense_pc_saved 0xc0
#define kbm_mode_sense_page 0x3f
#define k_mode_page_rw_err_recovery 0x01
#define k_mode_page_dct_rct 0x02
#define k_mode_page_format_device 0x03
#define k_mode_page_rigid_disk 0x04
#define k_mode_page_flexible_disk 0x05
#define k_mode_page_verify_error_recovery 0x07
#define k_mode_page_caching 0x08
#define k_mode_page_control 0x0a
#define k_mode_page_medium_types 0x0b
#define k_mode_page_notch 0x0c
#define k_mode_page_power_condition 0x0d
#define k_mode_page_xor_control 0x10
#define k_mode_page_info_excpt_ctl 0x1c
#define k_mode_page_all 0x3f
// Mode Page List Header
typedef struct s_mode_page_header
{
uint16 data_length;
uint8 medium_type;
uint8 device_specific;
uint8 reserved_1;
uint8 reserved_2;
uint16 block_descriptor_length;
} t_str_mode_page_header;
#define k_sz_mode_page_header 0x08
typedef uint8 t_buf_mode_page_header[k_sz_mode_page_header];
//------------------------------------------------------------------------------
// read write error recovery
#define k_mode_page_rw_err_recovery_page_length 0x0a
#define kbm_mode_page_rw_err_opt2_awre 0x80
#define kbm_mode_page_rw_err_opt2_arre 0x40
#define kbm_mode_page_rw_err_opt2_tb 0x20
#define kbm_mode_page_rw_err_opt2_rc 0x10
#define kbm_mode_page_rw_err_opt2_eer 0x08
#define kbm_mode_page_rw_err_opt2_per 0x04
#define kbm_mode_page_rw_err_opt2_dte 0x02
#define kbm_mode_page_rw_err_opt2_dcr 0x01
typedef struct s_mode_page_rw_err
{
uint8 page_code;
uint8 page_length;
uint8 opt2;
uint8 read_retry_count;
uint8 correction_span;
uint8 head_offset_count;
uint8 data_strobe_offset_count;
uint8 reserved_1;
uint8 write_retry_count;
uint8 reserved_2;
uint16 recovery_time_limit;
} t_str_mode_page_rw_err;
#define k_sz_mode_page_rw_err_recovery (k_mode_page_rw_err_recovery_page_length+2)
typedef uint8 t_buf_mode_page_rw_err[k_sz_mode_page_rw_err_recovery];
extern code t_buf_mode_page_rw_err mode_page_rw_err;
//------------------------------------------------------------------------------
// Disconnect/Reconnect Page (0x02)
#define k_mode_page_dct_rct_page_length 0x0e
#define kbm_mode_page_dct_rct_opt_12_emdp 0x80
#define kbm_mode_page_dct_rct_opt_12_fard 0x40
#define kbm_mode_page_dct_rct_opt_12_fawrt 0x20
#define kbm_mode_page_dct_rct_opt_12_fastat 0x10
#define kbm_mode_page_dct_rct_opt_12_dimm 0x08 // disconnect immediate
#define kbm_msk_mode_page_dct_rct_opt_dtdc 0x07 // data transfer disconnect ctl
#define k_dct_rct_opt_dtdc_not_used 0x00
#define k_dct_rct_opt_dtdc_data 0x01
#define k_dct_rct_opt_dtdc_data_and_complete 0x03
typedef struct s_disconnect_reconnect_page
{
uint8 page_code;
uint8 page_length;
uint8 buffer_full_ratio;
uint8 buffer_empty_ratio;
uint16 bus_inactivity_limit;
uint16 disconenct_time_limit;
uint16 connect_time_limit;
uint16 max_burst_size;
uint8 opt_12;
uint8 reserved;
uint16 first_burst_size;
} t_str_mode_page_dct_rct;
#define k_sz_mode_page_dct_rct (k_mode_page_dct_rct_page_length + 2)
typedef uint8 t_buf_mode_page_dct_rct[k_sz_mode_page_dct_rct];
extern code t_buf_mode_page_dct_rct mode_page_dct_rct;
//------------------------------------------------------------------------------
// format device page (0x03)
#define k_mode_page_format_device_page_length 0x16
#define k_sz_mode_page_format_device (k_mode_page_format_device_page_length + 2)
#define kbm_msk_mode_page_format_device_opt1_valid 0xf0
#define kbm_mode_page_format_device_opt1_ssec 0x80 // soft sector formatting
#define kbm_mode_page_format_device_opt1_hsec 0x40 // hard sector formmating
#define kbm_mode_page_format_device_opt1_rmb 0x20 // removable media supported
#define kbm_mode_page_format_device_opt1_surf 0x10 // surface bit
typedef struct s_mode_page_format_device
{
uint8 page_code;
uint8 page_length;
uint16 tracks_per_zone;
uint16 alt_sectors_per_zone;
uint16 alt_tracks_per_zone;
uint16 alt_tracks_per_lun;
uint16 sectors_per_track;
uint16 data_bytes_per_physical_sector;
uint16 interleave;
uint16 track_skew_factor;
uint16 cylinder_skew_factor;
uint8 opt1;
uint16 reserved;
} t_str_mode_page_format_device;
typedef uint8 t_buf_mode_page_format_device[k_sz_mode_page_format_device];
typedef uint8 t_buf_mode_page_format_device_changeable[k_sz_mode_page_format_device];
typedef uint8 t_buf_mode_page_format_device_default[k_sz_mode_page_format_device];
typedef uint8 t_buf_mode_page_format_device_saved[k_sz_mode_page_format_device];
extern code t_buf_mode_page_format_device mode_page_format_device;
//------------------------------------------------------------------------------
// rigid disk geometry page (0x04)
#define k_mode_page_rigid_disk_page_length 0x16
#define kbm_msk_mode_page_rigid_disk_opt17_rpl 0x03
typedef struct s_rigid_disk_page
{
uint8 page_code;
uint8 page_length;
uint16 num_cylinders;
uint8 num_heads;
uint16 start_cyl_write_precomp;
uint16 start_cyl_reduced_write_current;
uint16 device_step_rate;
uint16 landing_zone_cylinder;
uint8 opt17;
uint8 rotational_offset;
uint8 reserved_1;
uint16 medium_rotation_rate;
uint16 reserved_2;
} t_rigid_disk_page;
#define k_sz_mode_page_rigid_disk (k_mode_page_rigid_disk_page_length+2)
typedef uint8 t_buf_mode_page_rigid_disk[k_sz_mode_page_rigid_disk];
extern code t_buf_mode_page_rigid_disk mode_page_rigid_disk;
//------------------------------------------------------------------------------
// flexible disk page (0x05)
#define k_sz_mode_page_fd_page_length 0x1e
#define k_sz_mode_page_fd (k_sz_mode_page_fd_page_length + 2)
#define kbm_opt_21_trdy 0x80
#define kbm_opt_21_ssn 0x40
#define kbm_opt_21_mo 0x20
#define kbm_msk_pin34 0xf0
#define kbm_msk_pin2 0x0f
#define kbm_msk_pin4 0xf0
#define kbm_msk_pin1 0x0f
typedef struct s_flex_disk
{
uint8 page_code;
uint8 page_length;
uint16 transfer_rate;
uint8 num_heads;
uint8 sec_per_track;
uint16 bytes_per_sec;
uint16 num_cylinders;
uint16 start_cyl_write_precomp;
uint16 start_cyl_reduce_write_current;
uint16 device_step_rate;
uint8 device_step_pulse_width;
uint16 head_settle_delay;
uint8 motor_on_delay;
uint8 motor_off_delay;
uint8 opt_21;
uint8 spc;
uint8 write_compensation;
uint8 head_load_delay;
uint8 head_unload_delay;
uint8 Pin34_Pin2;
uint8 Pin4_Pin1;
uint16 medium_rotation_rate;
uint16 reserved;
} t_str_flex_disk_page;
typedef uint8 t_buf_flex_disk_page[k_sz_mode_page_fd];
//------------------------------------------------------------------------------
// verify error recovery page
#define k_mode_page_verify_error_recovery_page_length 0x0a
#define k_sz_mode_page_verify_error_recovery (k_mode_page_verify_error_recovery_page_length + 2)
#define kbm_verify_error_recovery_opt2_eer 0x08
#define kbm_verify_error_recovery_opt2_per 0x04
#define kbm_verify_error_recovery_opt2_dte 0x02
#define kbm_verify_error_recovery_opt2_dcr 0x01
typedef struct s_verify_error_recovery_page
{
uint8 page_code;
uint8 page_length;
uint8 opt2;
uint8 verify_retry_count;
uint8 verify_correction_span;
uint8 reserved1;
uint8 reserved2;
uint8 reserved3;
uint8 reserved4;
uint8 reserved5;
uint16 verify_recovery_time_limit;
} t_str_verify_error_recovery_page;
typedef uint8 t_buf_verify_error_recovery_page[k_sz_mode_page_verify_error_recovery];
extern code t_buf_verify_error_recovery_page mode_page_verify_error_recovery;
//------------------------------------------------------------------------------
// caching page (0x08)
#define k_mode_page_caching_page_length 0x12 // page length field... actual page buffer size is 14
#define kbm_mode_page_caching_opt1_ic 0x80 // initiator control
#define kbm_mode_page_caching_opt1_abpf 0x40 // abort prefetch
#define kbm_mode_page_caching_opt1_cap 0x20 // caching analysis permitted
#define kbm_mode_page_caching_opt1_disc 0x10 // discontinuity bit
#define kbm_mode_page_caching_opt1_size 0x08 // cache segment size enable
#define kbm_mode_page_caching_opt1_wce 0x04 // write cache enable
#define kbm_mode_page_caching_opt1_mf 0x02 // multiplication factor
#define kbm_mode_page_caching_opt1_rcd 0x01 // read cache disable
#define kbm_msk_mode_page_caching_rw_retention_priority_demand_read 0xf0 // demand read field of the rw retention priority
#define kbm_msk_mode_page_caching_rw_retention_priority_write 0x0f // write field of the rw retention priority
#define k_mode_page_caching_rw_retention_priority_demand_read_disable 0x00
#define k_mode_page_caching_rw_retention_priority_demand_read_low 0x10 // READ data has low priority compared to other in cache
#define k_mode_page_caching_rw_retention_priority_demand_read_hi 0xf0 // READ data has high priority compared to other in cache
#define k_mode_page_caching_rw_retention_priority_write_disable 0x00
#define k_mode_page_caching_rw_retention_priority_write_low 0x01
#define k_mode_page_caching_rw_retention_priority_write_hi 0x0f
#define kbm_msk_mode_page_caching_opt2_valid 0xf8 // valid bits mask. others are reserved
#define kbm_mode_page_caching_opt2_fsw 0x80 // force sequential write
#define kbm_mode_page_caching_opt2_lbcss 0x40 // logical block cache segment size
#define kbm_mode_page_caching_opt2_dra 0x20 // disable read-ahead
#define kbm_mode_page_caching_opt2_vs1 0x10 // vendor specific 1
#define kbm_mode_page_caching_opt2_vs2 0x20 // vendor specific 2
#define k_mode_page_caching_max_ncss ((uint32)0x00ffffffff) // max non-cache segment size
typedef struct s_mode_page_caching
{
uint8 page_code;
uint8 page_length;
uint8 opt1;
uint8 rw_retention_priority;
uint16 disable_prefetch_xfer_len;
uint16 min_prefetch;
uint16 max_prefetch;
uint16 max_prefetch_ceiling;
uint8 opt2;
uint8 num_cache_segments;
uint16 cache_segment_size;
uint32 non_cache_segment_size;
} t_str_mode_page_caching;
#define k_sz_mode_page_caching (k_mode_page_caching_page_length+2)
typedef uint8 t_buf_mode_page_caching[k_sz_mode_page_caching];
extern code t_buf_mode_page_caching mode_page_caching;
//------------------------------------------------------------------------------
// Control Page (0x0a)
#define k_mode_page_control_page_length 0x0a
#define kbm_mode_page_control_opt2_rlec 0x01 // report log exception condition
#define kbm_mode_page_control_opt2_gltsd 0x02 // global logging target save disable bit
#define kbm_mode_page_control_opt3_qam_mask 0xf0 // queue algorithm modifier mask
#define k_mode_page_control_opt3_qam_res_reordering 0x00
#define k_mode_page_control_opt3_qam_unres_reordering 0x10
#define kbm_mode_page_control_opt3_qerr 0x02
#define kbm_mode_page_control_opt3_dque 0x01
#define kbm_mode_page_control_opt4_rac 0x40
#define kbm_mode_page_control_opt4_swp 0x08
#define kbm_mode_page_control_opt4_raerp 0x04
#define kbm_mode_page_control_opt4_uaaerp 0x02
#define kbm_mode_page_control_opt4_eaerp 0x01
typedef struct s_control_page
{
uint8 page_code;
uint8 page_length;
uint8 opt_2;
uint8 opt_3;
uint8 opt_4;
uint8 reserved;
uint16 read_aer_holdoff_period;
uint16 busy_timeout_period;
uint8 reserved_1;
uint8 reserved_2;
} t_str_control_page;
#define k_sz_mode_page_control (k_mode_page_control_page_length + 2)
typedef uint8 t_mode_page_control[k_sz_mode_page_control];
extern code t_mode_page_control mode_page_control;
//------------------------------------------------------------------------------
// medium types supported (0x0b)
#define k_mode_page_medium_types_page_length 0x06
#define k_sz_mode_page_medium_types (k_mode_page_medium_types_page_length+2)
#define k_mode_page_medium_type_default 0x00
#define k_mode_page_medium_type_flex_single_unspec 0x01 // flexible disk, single sided, unspecified medium
#define k_mode_page_medium_type_flex_double_unspec 0x02 // flexible disk, double sided, unspecified medium
#define k_mode_page_medium_type_flex_single_1 0x04 // flexible disk, single sided,
typedef struct s_medium_types_supported_page
{
uint8 page_code;
uint8 page_length;
uint8 reserved_1;
uint8 reserved_2;
uint8 medium_type_1;
uint8 medium_type_2;
uint8 medium_type_3;
uint8 medium_type_4;
} t_str_medium_types_supported_page;
typedef uint8 t_buf_medium_types_page[k_sz_mode_page_medium_types];
extern code t_buf_medium_types_page mode_page_medium_types;
//------------------------------------------------------------------------------
// notch and partition page (0x0c)
#define k_mode_page_notch_page_length 0x16
#define k_sz_mode_page_notch (k_mode_page_notch_page_length + 2)
#define kbm_opt_2_nd 0x80
#define kbm_opt_2_lpn 0x40
typedef struct s_notch_page
{
uint8 page_code;
uint8 page_length;
uint8 opt_2;
uint8 reserved;
uint16 max_notches;
uint16 active_notch;
uint16 starting_boundry;
uint16 ending_boundry;
uint16 pages_notched;
} t_str_notch_page;
typedef uint8 t_buf_notch_page[k_sz_mode_page_notch];
extern code t_buf_notch_page mode_page_notch;
//------------------------------------------------------------------------------
// power condition 0d page (0x0d or 0x1a)
#define k_mode_page_power_condition_page_length 0x0a
#define k_sz_mode_page_power_condition (k_mode_page_power_condition_page_length+2)
#define kbm_mode_page_power_condition_opt3_idle 0x02
#define kbm_mode_page_power_condition_opt3_standby 0x01
typedef struct s_power_condition_page
{
uint8 page_code;
uint8 page_length;
uint8 reserved;
uint8 opt_3;
uint32 idle_condition_timer;
uint32 standby_condition_timer;
} t_str_power_condition_page;
typedef uint8 t_buf_power_condition[k_sz_mode_page_power_condition];
extern code t_buf_power_condition mode_page_power_condition;
//------------------------------------------------------------------------------
// xor control mode page (0x10)
#define k_mode_page_xor_control_page_length 0x16
#define kbm_mode_page_xor_control_opt2_xordis 0x02
typedef struct s_xor_control_page
{
uint8 page_code;
uint8 page_length;
uint8 opt_2;
uint8 reserved;
uint32 maximum_xor_write_size;
uint32 reserved2;
uint32 max_regenerate_size;
uint32 max_rebuild_read_size;
uint16 reserved3;
uint16 rebuild_delay;
} t_str_xor_control_page;
#define k_sz_mode_page_xor_control (k_mode_page_xor_control_page_length+2)
typedef uint8 t_buf_xor_control_page[k_sz_mode_page_xor_control];
extern code t_buf_xor_control_page mode_page_xor_control;
// ----------------------------------------------------------------------
// informational exceptions control page (0x1c)
// ----------------------------------------------------------------------
#define k_mode_page_info_excpt_ctl_page_length 0x0a
#define kbm_mode_page_info_excpt_ctl_opt2_perf 0x80 // performance bit
#define kbm_mode_page_info_excpt_ctl_opt2_dexcpt 0x08
#define kbm_mode_page_info_excpt_ctl_opt2_test 0x04
#define kbm_mode_page_info_excpt_ctl_opt2_logerr 0x01
#define k_mode_page_info_excpt_ctl_mrie_none 0x00 // no reporting
#define k_mode_page_info_excpt_ctl_aer 0x01 // asynch event reporting
#define k_mode_page_info_excpt_ctl_gua 0x02 // generate unit attention
#define k_mode_page_info_excpt_ctl_cgre 0x03 // conditionally generate recovered err
#define k_mode_page_info_excpt_ctl_ugre 0x04 // unconditionally generate recovered err
#define k_mode_page_info_excpt_ctl_nosense 0x05 // generate no sense
#define k_mode_page_info_excpt_ctl_onrequest 0x06 // only report info exception on request
typedef struct s_info_excpt_control_page
{
uint8 page_code;
uint8 page_length;
uint8 opt_2;
uint8 mrie;
uint32 interval_timer;
uint32 report_count;
} t_str_info_excpt_control_page;
#define k_sz_mode_page_info_excpt_ctl (k_mode_page_info_excpt_ctl_page_length+2)
typedef uint8 t_buf_info_excpt_ctl[k_sz_mode_page_info_excpt_ctl];
extern code t_buf_info_excpt_ctl mode_page_info_excpt_ctl;
extern code uint8 mode_page_all[];
#define k_sz_mode_page_all \
sizeof(mode_page_rw_err) + \
sizeof(mode_page_dct_rct) + \
sizeof(mode_page_format_device) + \
sizeof(mode_page_rigid_disk) + \
sizeof(mode_page_verify_error_recovery) + \
sizeof(mode_page_caching) + \
sizeof(mode_page_control) + \
sizeof(mode_page_medium_types) + \
sizeof(mode_page_notch) + \
sizeof(mode_page_power_condition) + \
sizeof(mode_page_info_excpt_ctl)
//------------------------------------------------------------------------------
// Request Sense
typedef struct s_sense
{
uint8 error_code;
uint8 reserved;
uint8 sense_key;
uint8 vendor_specific0[4];
uint8 additional_length;
uint8 vendor_specific1[4];
uint8 additional_sense_code;
uint8 asc_qualifier;
uint8 field_replacable_unit_code;
uint8 sense_key_specific[3];
} t_sense;
extern code t_sense sense_none;
extern code t_sense sense_bad_lun;
extern code t_sense sense_media_change;
extern code t_sense sense_no_media;
extern code t_sense sense_read_error;
extern code t_sense sense_fmt_failed;
extern code t_sense sense_no_seek;
extern code t_sense sense_por;
extern code t_sense sense_illegal_request;
extern code t_sense sense_write_error;
extern code t_sense sense_no_fmt;
extern code t_sense sense_write_protect;
extern code t_sense sense_write_protect_hw;
extern code t_sense sense_write_protect_sw_lun;
extern code t_sense sense_write_protect_assoc;
extern code t_sense sense_write_protect_persist;
extern code t_sense sense_write_protect_perm;
extern code t_sense sense_illegal_cmdpkt;
extern code t_sense sense_saving_not_support;
extern code t_sense sense_illegal_length;
extern code t_sense sense_illegal_address;
extern code t_sense sense_illegal_opcode;
extern code t_sense sense_becoming_ready;
//------------------------------------------------------------------------------
// Start Stop Unit
#define kbm_scsi_ssu_msk_immed 0x01 // 0 => return on completion, 1 => return after cbw validation
#define kbm_scsi_ssu_msk_pc 0xf0 // power conditions
#define k_scsi_ssu_pc_nc 0x00 // no change in pc
#define k_scsi_ssu_pc_active 0x10 // place device in active power condition
#define k_scsi_ssu_pc_idle 0x20 // place device in idle power condition
#define k_scsi_ssu_pc_standby 0x30 // place device in standby power condition
#define k_scsi_ssu_pc_sleep 0x50 // place device in sleep power condition
#define k_scsi_ssu_pc_dev_ctl 0x70 // leave control of power condition to device
#define k_scsi_ssu_pc_idle_cdm_0 0xa0 // force idle timer (chronal displacement monitor) to 0
#define k_scsi_ssu_pc_standby_cdm_0 0xb0 // force standby time to 0
#define kbm_scsi_ssu_msk_action 0x03 // load-or-eject / start-stop action
#define kbm_scsi_ssu_action_stop 0x00 // stop device only (do not unload)
#define kbm_scsi_ssu_action_start 0x01 // start device only (do not load media)
#define kbm_scsi_ssu_action_unload 0x02 // eject (or unload) media
#define kbm_scsi_ssu_action_load 0x03 // load media
typedef struct s_param_start_stop_unit
{
uint8 opts;
uint8 reserved1 ;
uint8 reserved2 ;
uint8 pc_action ;
uint8 control;
} t_param_start_stop_unit;
//------------------------------------------------------------------------------
// union of all that is atapi
typedef struct s_atapi_cb
{
uint8 opcode;
union u_atapi_parameters
{
t_param_rw rw;
t_param_verify verify;
#if 0
t_param_req_sense req_sense;
t_param_inquiry inquiry;
t_param_mode_sense mode_sense;
t_param_mode_select mode_select;
t_param_rd_cap rd_cap;
t_param_rd_fmt_cap rd_fmt_cap;
#endif
uint8 bytes[15];
} param;
} t_atapi_cb;
// union of all that is scsi
typedef struct s_scsi_cb
{
uint8 opcode;
union u_scsi_params
{
t_param_rw rw ;
t_param_verify verify ;
t_param_start_stop_unit start_stop_unit ;
t_param_read_format_capacity read_format_capacity ;
#if 0
t_param_mode_sense6 mode_sense6 ;
t_param_mode_sense10 mode_sense10 ;
#endif
uint8 bytes[15];
} param ;
} t_scsi_cb ;
//------------------------------------------------------------------------------
// globally accessible flags and variables
//extern uint16 g_intr_cnt; // count ata intr vs. ide INTR detections
extern bit g_use_dma;
extern bit g_disable_iordy;
// ata device characteristics
extern xdata uint8 g_dev_max_dma_mode; // represents max DMA mode supported by the device
//------------------------------------------------------------------------------
// fatal exception handling
void dev_exception(uint16 err) reentrant;
#define k_err_none (0)
#define k_err_unreachable_code (1)
#define k_err_unexpected_synchronizer (2)
//---eof------------------------------------------------------------------------