protocol.h

<B>SMSC USB2.0 Flash硬盘驱动源码</B>

#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,