diff options
Diffstat (limited to '')
| -rw-r--r-- | atacmds.h | 1004 |
1 files changed, 1004 insertions, 0 deletions
diff --git a/atacmds.h b/atacmds.h new file mode 100644 index 0000000..6bdf0b6 --- /dev/null +++ b/atacmds.h @@ -0,0 +1,1004 @@ +/* + * atacmds.h + * + * Home page of code is: https://www.smartmontools.org + * + * Copyright (C) 2002-11 Bruce Allen + * Copyright (C) 2008-19 Christian Franke + * Copyright (C) 1999-2000 Michael Cornwell <cornwell@acm.org> + * + * SPDX-License-Identifier: GPL-2.0-or-later + */ + +#ifndef ATACMDS_H_ +#define ATACMDS_H_ + +#define ATACMDS_H_CVSID "$Id: atacmds.h 5166 2021-01-15 18:02:19Z chrfranke $" + +#include "dev_interface.h" // ata_device +#include "static_assert.h" + +// Add __attribute__((packed)) if compiler supports it +// because some gcc versions (at least ARM) lack support of #pragma pack() +#ifdef HAVE_ATTR_PACKED +#define ATTR_PACKED __attribute__((packed)) +#else +#define ATTR_PACKED +#endif + +typedef enum { + // returns no data, just succeeds or fails + ENABLE, + DISABLE, + AUTOSAVE, + IMMEDIATE_OFFLINE, + AUTO_OFFLINE, + STATUS, // just says if SMART is working or not + STATUS_CHECK, // says if disk's SMART status is healthy, or failing + // return 512 bytes of data: + READ_VALUES, + READ_THRESHOLDS, + READ_LOG, + IDENTIFY, + PIDENTIFY, + // returns 1 byte of data + CHECK_POWER_MODE, + // writes 512 bytes of data: + WRITE_LOG +} smart_command_set; + + +// ATA Specification Command Register Values (Commands) +#define ATA_CHECK_POWER_MODE 0xe5 +#define ATA_IDENTIFY_DEVICE 0xec +#define ATA_IDENTIFY_PACKET_DEVICE 0xa1 +#define ATA_IDLE 0xe3 +#define ATA_SMART_CMD 0xb0 +#define ATA_SECURITY_FREEZE_LOCK 0xf5 +#ifndef ATA_SET_FEATURES +#define ATA_SET_FEATURES 0xef +#endif +#define ATA_STANDBY 0xe2 +#define ATA_STANDBY_IMMEDIATE 0xe0 + +// SET_FEATURES subcommands +#define ATA_DISABLE_AAM 0xc2 +#define ATA_DISABLE_APM 0x85 +#define ATA_DISABLE_WRITE_CACHE 0x82 +#define ATA_DISABLE_READ_LOOK_AHEAD 0x55 +#define ATA_ENABLE_AAM 0x42 +#define ATA_ENABLE_APM 0x05 +#define ATA_ENABLE_WRITE_CACHE 0x02 +#define ATA_ENABLE_READ_LOOK_AHEAD 0xaa +#define ATA_ENABLE_DISABLE_DSN 0x63 + +// 48-bit commands +#define ATA_READ_LOG_EXT 0x2F +#define ATA_WRITE_LOG_EXT 0x3f + +// ATA Specification Feature Register Values (SMART Subcommands). +// Note that some are obsolete as of ATA-7. +#define ATA_SMART_READ_VALUES 0xd0 +#define ATA_SMART_READ_THRESHOLDS 0xd1 +#define ATA_SMART_AUTOSAVE 0xd2 +#define ATA_SMART_SAVE 0xd3 +#define ATA_SMART_IMMEDIATE_OFFLINE 0xd4 +#define ATA_SMART_READ_LOG_SECTOR 0xd5 +#define ATA_SMART_WRITE_LOG_SECTOR 0xd6 +#define ATA_SMART_WRITE_THRESHOLDS 0xd7 +#define ATA_SMART_ENABLE 0xd8 +#define ATA_SMART_DISABLE 0xd9 +#define ATA_SMART_STATUS 0xda +// SFF 8035i Revision 2 Specification Feature Register Value (SMART +// Subcommand) +#define ATA_SMART_AUTO_OFFLINE 0xdb + +// Sector Number values for ATA_SMART_IMMEDIATE_OFFLINE Subcommand +#define OFFLINE_FULL_SCAN 0 +#define SHORT_SELF_TEST 1 +#define EXTEND_SELF_TEST 2 +#define CONVEYANCE_SELF_TEST 3 +#define SELECTIVE_SELF_TEST 4 +#define ABORT_SELF_TEST 127 +#define SHORT_CAPTIVE_SELF_TEST 129 +#define EXTEND_CAPTIVE_SELF_TEST 130 +#define CONVEYANCE_CAPTIVE_SELF_TEST 131 +#define SELECTIVE_CAPTIVE_SELF_TEST 132 +#define CAPTIVE_MASK (0x01<<7) + +// Maximum allowed number of SMART Attributes +#define NUMBER_ATA_SMART_ATTRIBUTES 30 + +// Needed parts of the ATA DRIVE IDENTIFY Structure. Those labeled +// word* are NOT used. +#pragma pack(1) +struct ata_identify_device { + unsigned short words000_009[10]; + unsigned char serial_no[20]; + unsigned short words020_022[3]; + unsigned char fw_rev[8]; + unsigned char model[40]; + unsigned short words047_079[33]; + unsigned short major_rev_num; + unsigned short minor_rev_num; + unsigned short command_set_1; + unsigned short command_set_2; + unsigned short command_set_extension; + unsigned short cfs_enable_1; + unsigned short word086; + unsigned short csf_default; + unsigned short words088_255[168]; +} ATTR_PACKED; +#pragma pack() +STATIC_ASSERT(sizeof(ata_identify_device) == 512); + +/* ata_smart_attribute is the vendor specific in SFF-8035 spec */ +#pragma pack(1) +struct ata_smart_attribute { + unsigned char id; + // meaning of flag bits: see MACROS just below + // WARNING: MISALIGNED! + unsigned short flags; + unsigned char current; + unsigned char worst; + unsigned char raw[6]; + unsigned char reserv; +} ATTR_PACKED; +#pragma pack() +STATIC_ASSERT(sizeof(ata_smart_attribute) == 12); + +// MACROS to interpret the flags bits in the previous structure. +// These have not been implemented using bitflags and a union, to make +// it portable across bit/little endian and different platforms. + +// 0: Prefailure bit + +// From SFF 8035i Revision 2 page 19: Bit 0 (pre-failure/advisory bit) +// - If the value of this bit equals zero, an attribute value less +// than or equal to its corresponding attribute threshold indicates an +// advisory condition where the usage or age of the device has +// exceeded its intended design life period. If the value of this bit +// equals one, an attribute value less than or equal to its +// corresponding attribute threshold indicates a prefailure condition +// where imminent loss of data is being predicted. +#define ATTRIBUTE_FLAGS_PREFAILURE(x) (x & 0x01) + +// 1: Online bit + +// From SFF 8035i Revision 2 page 19: Bit 1 (on-line data collection +// bit) - If the value of this bit equals zero, then the attribute +// value is updated only during off-line data collection +// activities. If the value of this bit equals one, then the attribute +// value is updated during normal operation of the device or during +// both normal operation and off-line testing. +#define ATTRIBUTE_FLAGS_ONLINE(x) (x & 0x02) + + +// The following are (probably) IBM's, Maxtors and Quantum's definitions for the +// vendor-specific bits: +// 2: Performance type bit +#define ATTRIBUTE_FLAGS_PERFORMANCE(x) (x & 0x04) + +// 3: Errorrate type bit +#define ATTRIBUTE_FLAGS_ERRORRATE(x) (x & 0x08) + +// 4: Eventcount bit +#define ATTRIBUTE_FLAGS_EVENTCOUNT(x) (x & 0x10) + +// 5: Selfpereserving bit +#define ATTRIBUTE_FLAGS_SELFPRESERVING(x) (x & 0x20) + +// 6-15: Reserved for future use +#define ATTRIBUTE_FLAGS_OTHER(x) ((x) & 0xffc0) + + +// Format of data returned by SMART READ DATA +// Table 62 of T13/1699-D (ATA8-ACS) Revision 6a, September 2008 +#pragma pack(1) +struct ata_smart_values { + unsigned short int revnumber; + struct ata_smart_attribute vendor_attributes [NUMBER_ATA_SMART_ATTRIBUTES]; + unsigned char offline_data_collection_status; + unsigned char self_test_exec_status; //IBM # segments for offline collection + unsigned short int total_time_to_complete_off_line; // IBM different + unsigned char vendor_specific_366; // Maxtor & IBM current segment pointer + unsigned char offline_data_collection_capability; + unsigned short int smart_capability; + unsigned char errorlog_capability; + unsigned char vendor_specific_371; // Maxtor, IBM: self-test failure checkpoint see below! + unsigned char short_test_completion_time; + unsigned char extend_test_completion_time_b; // If 0xff, use 16-bit value below + unsigned char conveyance_test_completion_time; + unsigned short extend_test_completion_time_w; // e04130r2, added to T13/1699-D Revision 1c, April 2005 + unsigned char reserved_377_385[9]; + unsigned char vendor_specific_386_510[125]; // Maxtor bytes 508-509 Attribute/Threshold Revision # + unsigned char chksum; +} ATTR_PACKED; +#pragma pack() +STATIC_ASSERT(sizeof(ata_smart_values) == 512); + +/* Maxtor, IBM: self-test failure checkpoint byte meaning: + 00 - write test + 01 - servo basic + 02 - servo random + 03 - G-list scan + 04 - Handling damage + 05 - Read scan +*/ + +/* Vendor attribute of SMART Threshold (compare to ata_smart_attribute above) */ +#pragma pack(1) +struct ata_smart_threshold_entry { + unsigned char id; + unsigned char threshold; + unsigned char reserved[10]; +} ATTR_PACKED; +#pragma pack() +STATIC_ASSERT(sizeof(ata_smart_threshold_entry) == 12); + +/* Format of Read SMART THreshold Command */ +/* Compare to ata_smart_values above */ +#pragma pack(1) +struct ata_smart_thresholds_pvt { + unsigned short int revnumber; + struct ata_smart_threshold_entry thres_entries[NUMBER_ATA_SMART_ATTRIBUTES]; + unsigned char reserved[149]; + unsigned char chksum; +} ATTR_PACKED; +#pragma pack() +STATIC_ASSERT(sizeof(ata_smart_thresholds_pvt) == 512); + + +// Table 42 of T13/1321D Rev 1 spec (Error Data Structure) +#pragma pack(1) +struct ata_smart_errorlog_error_struct { + unsigned char reserved; + unsigned char error_register; + unsigned char sector_count; + unsigned char sector_number; + unsigned char cylinder_low; + unsigned char cylinder_high; + unsigned char drive_head; + unsigned char status; + unsigned char extended_error[19]; + unsigned char state; + unsigned short timestamp; +} ATTR_PACKED; +#pragma pack() +STATIC_ASSERT(sizeof(ata_smart_errorlog_error_struct) == 30); + + +// Table 41 of T13/1321D Rev 1 spec (Command Data Structure) +#pragma pack(1) +struct ata_smart_errorlog_command_struct { + unsigned char devicecontrolreg; + unsigned char featuresreg; + unsigned char sector_count; + unsigned char sector_number; + unsigned char cylinder_low; + unsigned char cylinder_high; + unsigned char drive_head; + unsigned char commandreg; + unsigned int timestamp; +} ATTR_PACKED; +#pragma pack() +STATIC_ASSERT(sizeof(ata_smart_errorlog_command_struct) == 12); + +// Table 40 of T13/1321D Rev 1 spec (Error log data structure) +#pragma pack(1) +struct ata_smart_errorlog_struct { + struct ata_smart_errorlog_command_struct commands[5]; + struct ata_smart_errorlog_error_struct error_struct; +} ATTR_PACKED; +#pragma pack() +STATIC_ASSERT(sizeof(ata_smart_errorlog_struct) == 90); + +// Table 39 of T13/1321D Rev 1 spec (SMART error log sector) +#pragma pack(1) +struct ata_smart_errorlog { + unsigned char revnumber; + unsigned char error_log_pointer; + struct ata_smart_errorlog_struct errorlog_struct[5]; + unsigned short int ata_error_count; + unsigned char reserved[57]; + unsigned char checksum; +} ATTR_PACKED; +#pragma pack() +STATIC_ASSERT(sizeof(ata_smart_errorlog) == 512); + + +// Extended Comprehensive SMART Error Log data structures +// See Section A.7 of +// AT Attachment 8 - ATA/ATAPI Command Set (ATA8-ACS) +// T13/1699-D Revision 6a (Working Draft), September 6, 2008. + +// Command data structure +// Table A.9 of T13/1699-D Revision 6a +#pragma pack(1) +struct ata_smart_exterrlog_command +{ + unsigned char device_control_register; + unsigned char features_register; + unsigned char features_register_hi; + unsigned char count_register; + unsigned char count_register_hi; + unsigned char lba_low_register; + unsigned char lba_low_register_hi; + unsigned char lba_mid_register; + unsigned char lba_mid_register_hi; + unsigned char lba_high_register; + unsigned char lba_high_register_hi; + unsigned char device_register; + unsigned char command_register; + + unsigned char reserved; + unsigned int timestamp; +} ATTR_PACKED; +#pragma pack() +STATIC_ASSERT(sizeof(ata_smart_exterrlog_command) == 18); + +// Error data structure +// Table A.10 T13/1699-D Revision 6a +#pragma pack(1) +struct ata_smart_exterrlog_error +{ + unsigned char device_control_register; + unsigned char error_register; + unsigned char count_register; + unsigned char count_register_hi; + unsigned char lba_low_register; + unsigned char lba_low_register_hi; + unsigned char lba_mid_register; + unsigned char lba_mid_register_hi; + unsigned char lba_high_register; + unsigned char lba_high_register_hi; + unsigned char device_register; + unsigned char status_register; + + unsigned char extended_error[19]; + unsigned char state; + unsigned short timestamp; +} ATTR_PACKED; +#pragma pack() +STATIC_ASSERT(sizeof(ata_smart_exterrlog_error) == 34); + +// Error log data structure +// Table A.8 of T13/1699-D Revision 6a +#pragma pack(1) +struct ata_smart_exterrlog_error_log +{ + ata_smart_exterrlog_command commands[5]; + ata_smart_exterrlog_error error; +} ATTR_PACKED; +#pragma pack() +STATIC_ASSERT(sizeof(ata_smart_exterrlog_error_log) == 124); + +// Ext. Comprehensive SMART error log +// Table A.7 of T13/1699-D Revision 6a +#pragma pack(1) +struct ata_smart_exterrlog +{ + unsigned char version; + unsigned char reserved1; + unsigned short error_log_index; + ata_smart_exterrlog_error_log error_logs[4]; + unsigned short device_error_count; + unsigned char reserved2[9]; + unsigned char checksum; +} ATTR_PACKED; +#pragma pack() +STATIC_ASSERT(sizeof(ata_smart_exterrlog) == 512); + + +// Table 45 of T13/1321D Rev 1 spec (Self-test log descriptor entry) +#pragma pack(1) +struct ata_smart_selftestlog_struct { + unsigned char selftestnumber; // Sector number register + unsigned char selfteststatus; + unsigned short int timestamp; + unsigned char selftestfailurecheckpoint; + unsigned int lbafirstfailure; + unsigned char vendorspecific[15]; +} ATTR_PACKED; +#pragma pack() +STATIC_ASSERT(sizeof(ata_smart_selftestlog_struct) == 24); + +// Table 44 of T13/1321D Rev 1 spec (Self-test log data structure) +#pragma pack(1) +struct ata_smart_selftestlog { + unsigned short int revnumber; + struct ata_smart_selftestlog_struct selftest_struct[21]; + unsigned char vendorspecific[2]; + unsigned char mostrecenttest; + unsigned char reserved[2]; + unsigned char chksum; +} ATTR_PACKED; +#pragma pack() +STATIC_ASSERT(sizeof(ata_smart_selftestlog) == 512); + +// Extended SMART Self-test log data structures +// See Section A.8 of +// AT Attachment 8 - ATA/ATAPI Command Set (ATA8-ACS) +// T13/1699-D Revision 6a (Working Draft), September 6, 2008. + +// Extended Self-test log descriptor entry +// Table A.13 of T13/1699-D Revision 6a +#pragma pack(1) +struct ata_smart_extselftestlog_desc +{ + unsigned char self_test_type; + unsigned char self_test_status; + unsigned short timestamp; + unsigned char checkpoint; + unsigned char failing_lba[6]; + unsigned char vendorspecific[15]; +} ATTR_PACKED; +#pragma pack() +STATIC_ASSERT(sizeof(ata_smart_extselftestlog_desc) == 26); + +// Extended Self-test log data structure +// Table A.12 of T13/1699-D Revision 6a +#pragma pack(1) +struct ata_smart_extselftestlog +{ + unsigned char version; + unsigned char reserved1; + unsigned short log_desc_index; + struct ata_smart_extselftestlog_desc log_descs[19]; + unsigned char vendor_specifc[2]; + unsigned char reserved2[11]; + unsigned char chksum; +} ATTR_PACKED; +#pragma pack() +STATIC_ASSERT(sizeof(ata_smart_extselftestlog) == 512); + +// SMART LOG DIRECTORY Table 52 of T13/1532D Vol 1 Rev 1a +#pragma pack(1) +struct ata_smart_log_entry { + unsigned char numsectors; + unsigned char reserved; +} ATTR_PACKED; +#pragma pack() +STATIC_ASSERT(sizeof(ata_smart_log_entry) == 2); + +#pragma pack(1) +struct ata_smart_log_directory { + unsigned short int logversion; + struct ata_smart_log_entry entry[255]; +} ATTR_PACKED; +#pragma pack() +STATIC_ASSERT(sizeof(ata_smart_log_directory) == 512); + +// SMART SELECTIVE SELF-TEST LOG Table 61 of T13/1532D Volume 1 +// Revision 3 +#pragma pack(1) +struct test_span { + uint64_t start; + uint64_t end; +} ATTR_PACKED; +#pragma pack() +STATIC_ASSERT(sizeof(test_span) == 16); + +#pragma pack(1) +struct ata_selective_self_test_log { + unsigned short logversion; + struct test_span span[5]; + unsigned char reserved1[337-82+1]; + unsigned char vendor_specific1[491-338+1]; + uint64_t currentlba; + unsigned short currentspan; + unsigned short flags; + unsigned char vendor_specific2[507-504+1]; + unsigned short pendingtime; + unsigned char reserved2; + unsigned char checksum; +} ATTR_PACKED; +#pragma pack() +STATIC_ASSERT(sizeof(ata_selective_self_test_log) == 512); + +#define SELECTIVE_FLAG_DOSCAN (0x0002) +#define SELECTIVE_FLAG_PENDING (0x0008) +#define SELECTIVE_FLAG_ACTIVE (0x0010) + + +// SCT (SMART Command Transport) data structures +// See Sections 8.2 and 8.3 of: +// AT Attachment 8 - ATA/ATAPI Command Set (ATA8-ACS) +// T13/1699-D Revision 3f (Working Draft), December 11, 2006. + +// SCT Status response (read with SMART_READ_LOG page 0xe0) +// Table 194 of T13/BSR INCITS 529 (ACS-4) Revision 20, October 26, 2017 +#pragma pack(1) +struct ata_sct_status_response +{ + unsigned short format_version; // 0-1: Status response format version number (2, 3) + unsigned short sct_version; // 2-3: Vendor specific version number + unsigned short sct_spec; // 4-5: SCT level supported (1) + unsigned int status_flags; // 6-9: Status flags (Bit 0: Segment initialized, Bits 1-31: reserved) + unsigned char device_state; // 10: Device State (0-5) + unsigned char bytes011_013[3]; // 11-13: reserved + unsigned short ext_status_code; // 14-15: Status of last SCT command (0xffff if executing) + unsigned short action_code; // 16-17: Action code of last SCT command + unsigned short function_code; // 18-19: Function code of last SCT command + unsigned char bytes020_039[20]; // 20-39: reserved + uint64_t lba_current; // 40-47: LBA of SCT command executing in background + unsigned char bytes048_199[152]; // 48-199: reserved + signed char hda_temp; // 200: Current temperature in Celsius (0x80 = invalid) + signed char min_temp; // 201: Minimum temperature this power cycle + signed char max_temp; // 202: Maximum temperature this power cycle + signed char life_min_temp; // 203: Minimum lifetime temperature + signed char life_max_temp; // 204: Maximum lifetime temperature + signed char max_op_limit; // 205: Specified maximum operating temperature (ACS-4) + unsigned int over_limit_count; // 206-209: # intervals since last reset with temperature > Max Op Limit + unsigned int under_limit_count; // 210-213: # intervals since last reset with temperature < Min Op Limit + unsigned short smart_status; // 214-215: LBA(32:8) of SMART RETURN STATUS (0, 0x2cf4, 0xc24f) (ACS-4) + unsigned short min_erc_time; // 216-217: Minimum supported value for ERC (ACS-4) + unsigned char bytes216_479[479-218+1]; // 218-479: reserved + unsigned char vendor_specific[32];// 480-511: vendor specific +} ATTR_PACKED; +#pragma pack() +STATIC_ASSERT(sizeof(ata_sct_status_response) == 512); + +// SCT Error Recovery Control command (send with SMART_WRITE_LOG page 0xe0) +// Table 88 of T13/1699-D Revision 6a +#pragma pack(1) +struct ata_sct_error_recovery_control_command +{ + unsigned short action_code; // 3 = Error Recovery Control + unsigned short function_code; // 1 = Set Current, 2 = Return Current, 3 = Set Power-on, 4 = Return Power-on, 5 = Restore Default + unsigned short selection_code; // 1 = Read Timer, 2 = Write Timer + unsigned short time_limit; // If set: Recovery time limit in 100ms units + unsigned short words004_255[252]; // reserved +} ATTR_PACKED; +#pragma pack() +STATIC_ASSERT(sizeof(ata_sct_error_recovery_control_command) == 512); + +// SCT Feature Control command (send with SMART_WRITE_LOG page 0xe0) +// Table 72 of T13/1699-D Revision 3f +#pragma pack(1) +struct ata_sct_feature_control_command +{ + unsigned short action_code; // 4 = Feature Control + unsigned short function_code; // 1 = Set, 2 = Return, 3 = Return options + unsigned short feature_code; // 3 = Temperature logging interval + unsigned short state; // Interval + unsigned short option_flags; // Bit 0: persistent, Bits 1-15: reserved + unsigned short words005_255[251]; // reserved +} ATTR_PACKED; +#pragma pack() +STATIC_ASSERT(sizeof(ata_sct_feature_control_command) == 512); + +// SCT Data Table command (send with SMART_WRITE_LOG page 0xe0) +// Table 73 of T13/1699-D Revision 3f +#pragma pack(1) +struct ata_sct_data_table_command +{ + unsigned short action_code; // 5 = Data Table + unsigned short function_code; // 1 = Read Table + unsigned short table_id; // 2 = Temperature History + unsigned short words003_255[253]; // reserved +} ATTR_PACKED; +#pragma pack() +STATIC_ASSERT(sizeof(ata_sct_data_table_command) == 512); + +// SCT Temperature History Table (read with SMART_READ_LOG page 0xe1) +// Table 75 of T13/1699-D Revision 3f +#pragma pack(1) +struct ata_sct_temperature_history_table +{ + unsigned short format_version; // 0-1: Data table format version number (2) + unsigned short sampling_period; // 2-3: Temperature sampling period in minutes + unsigned short interval; // 4-5: Timer interval between history entries + signed char max_op_limit; // 6: Maximum recommended continuous operating temperature + signed char over_limit; // 7: Maximum temperature limit + signed char min_op_limit; // 8: Minimum recommended continuous operating limit + signed char under_limit; // 9: Minimum temperature limit + unsigned char bytes010_029[20]; // 10-29: reserved + unsigned short cb_size; // 30-31: Number of history entries (range 128-478) + unsigned short cb_index; // 32-33: Index of last updated entry (zero-based) + signed char cb[478]; // 34-(34+cb_size-1): Circular buffer of temperature values +} ATTR_PACKED; +#pragma pack() +STATIC_ASSERT(sizeof(ata_sct_temperature_history_table) == 512); + +// Possible values for span_args.mode +enum { + SEL_RANGE, // MIN-MAX + SEL_REDO, // redo this + SEL_NEXT, // do next range + SEL_CONT // redo or next depending of last test status +}; + +// Arguments for selective self-test +struct ata_selective_selftest_args +{ + // Arguments for each span + struct span_args + { + uint64_t start; // First block + uint64_t end; // Last block + int mode; // SEL_*, see above + + span_args() + : start(0), end(0), mode(SEL_RANGE) { } + }; + + span_args span[5]; // Range and mode for 5 spans + int num_spans; // Number of spans + int pending_time; // One plus time in minutes to wait after powerup before restarting + // interrupted offline scan after selective self-test. + int scan_after_select; // Run offline scan after selective self-test: + // 0: don't change, + // 1: turn off scan after selective self-test, + // 2: turn on scan after selective self-test. + + ata_selective_selftest_args() + : num_spans(0), pending_time(0), scan_after_select(0) { } +}; + +// Priority for vendor attribute defs +enum ata_vendor_def_prior +{ + PRIOR_DEFAULT, + PRIOR_DATABASE, + PRIOR_USER +}; + +// Raw attribute value print formats +enum ata_attr_raw_format +{ + RAWFMT_DEFAULT, + RAWFMT_RAW8, + RAWFMT_RAW16, + RAWFMT_RAW48, + RAWFMT_HEX48, + RAWFMT_RAW56, + RAWFMT_HEX56, + RAWFMT_RAW64, + RAWFMT_HEX64, + RAWFMT_RAW16_OPT_RAW16, + RAWFMT_RAW16_OPT_AVG16, + RAWFMT_RAW24_OPT_RAW8, + RAWFMT_RAW24_DIV_RAW24, + RAWFMT_RAW24_DIV_RAW32, + RAWFMT_SEC2HOUR, + RAWFMT_MIN2HOUR, + RAWFMT_HALFMIN2HOUR, + RAWFMT_MSEC24_HOUR32, + RAWFMT_TEMPMINMAX, + RAWFMT_TEMP10X, +}; + +// Attribute flags +enum { + ATTRFLAG_INCREASING = 0x01, // Value not reset (for reallocated/pending counts) + ATTRFLAG_NO_NORMVAL = 0x02, // Normalized value not valid + ATTRFLAG_NO_WORSTVAL = 0x04, // Worst value not valid + ATTRFLAG_HDD_ONLY = 0x08, // DEFAULT setting for HDD only + ATTRFLAG_SSD_ONLY = 0x10, // DEFAULT setting for SSD only +}; + +// Vendor attribute display defs for all attribute ids +class ata_vendor_attr_defs +{ +public: + struct entry + { + std::string name; // Attribute name, empty for default + ata_attr_raw_format raw_format; // Raw value print format + ata_vendor_def_prior priority; // Setting priority + unsigned flags; // ATTRFLAG_* + char byteorder[8+1]; // String [012345rvwz] to define byte order + + entry() + : raw_format(RAWFMT_DEFAULT), + priority(PRIOR_DEFAULT), + flags(0) + { byteorder[0] = 0; } + }; + + entry & operator[](unsigned char id) + { return m_defs[id]; } + + const entry & operator[](unsigned char id) const + { return m_defs[id]; } + +private: + entry m_defs[256]; +}; + + +// Possible values for firmwarebugs +enum firmwarebug_t { + BUG_NONE = 0, + BUG_NOLOGDIR, + BUG_SAMSUNG, + BUG_SAMSUNG2, + BUG_SAMSUNG3, + BUG_XERRORLBA +}; + +// Set of firmware bugs +class firmwarebug_defs +{ +public: + firmwarebug_defs() + : m_bugs(0) { } + + bool is_set(firmwarebug_t bug) const + { return !!(m_bugs & (1 << bug)); } + + void set(firmwarebug_t bug) + { m_bugs |= (1 << bug); } + + void set(firmwarebug_defs bugs) + { m_bugs |= bugs.m_bugs; } + +private: + unsigned m_bugs; +}; + + +// Print ATA debug messages? +extern unsigned char ata_debugmode; + +// Suppress serial number? +extern bool dont_print_serial_number; + +// Get information from drive +int ata_read_identity(ata_device * device, ata_identify_device * buf, bool fix_swapped_id, + unsigned char * raw_buf = 0); +int ataCheckPowerMode(ata_device * device); + +// Issue a no-data ATA command with optional sector count register value +bool ata_nodata_command(ata_device * device, unsigned char command, int sector_count = -1); + +// Issue SET FEATURES command with optional sector count register value +bool ata_set_features(ata_device * device, unsigned char features, int sector_count = -1); + +/* Read S.M.A.R.T information from drive */ +int ataReadSmartValues(ata_device * device,struct ata_smart_values *); +int ataReadSmartThresholds(ata_device * device, struct ata_smart_thresholds_pvt *); +int ataReadErrorLog (ata_device * device, ata_smart_errorlog *data, + firmwarebug_defs firmwarebugs); +int ataReadSelfTestLog(ata_device * device, ata_smart_selftestlog * data, + firmwarebug_defs firmwarebugs); +int ataReadSelectiveSelfTestLog(ata_device * device, struct ata_selective_self_test_log *data); +int ataReadLogDirectory(ata_device * device, ata_smart_log_directory *, bool gpl); + +// Write GP Log page(s) +bool ataWriteLogExt(ata_device * device, unsigned char logaddr, + unsigned page, void * data, unsigned nsectors); + +// Read GP Log page(s) +bool ataReadLogExt(ata_device * device, unsigned char logaddr, + unsigned char features, unsigned page, + void * data, unsigned nsectors); +// Read SMART Log page(s) +bool ataReadSmartLog(ata_device * device, unsigned char logaddr, + void * data, unsigned nsectors); +// Read SMART Extended Comprehensive Error Log +bool ataReadExtErrorLog(ata_device * device, ata_smart_exterrlog * log, + unsigned page, unsigned nsectors, firmwarebug_defs firmwarebugs); +// Read SMART Extended Self-test Log +bool ataReadExtSelfTestLog(ata_device * device, ata_smart_extselftestlog * log, + unsigned nsectors); + +// Read SCT information +int ataReadSCTStatus(ata_device * device, ata_sct_status_response * sts); +int ataReadSCTTempHist(ata_device * device, ata_sct_temperature_history_table * tmh, + ata_sct_status_response * sts); +// Set SCT temperature logging interval +int ataSetSCTTempInterval(ata_device * device, unsigned interval, bool persistent); + +// Get/Set SCT Error Recovery Control +int ataGetSCTErrorRecoveryControltime(ata_device * device, unsigned type, unsigned short & time_limit, bool power_on); +int ataSetSCTErrorRecoveryControltime(ata_device * device, unsigned type, unsigned short time_limit, bool power_on, bool mfg_default); + + +/* Enable/Disable SMART on device */ +int ataEnableSmart (ata_device * device); +int ataDisableSmart (ata_device * device); +int ataEnableAutoSave(ata_device * device); +int ataDisableAutoSave(ata_device * device); + +/* Automatic Offline Testing */ +int ataEnableAutoOffline (ata_device * device); +int ataDisableAutoOffline (ata_device * device); + +/* S.M.A.R.T. test commands */ +int ataSmartTest(ata_device * device, int testtype, bool force, + const ata_selective_selftest_args & args, + const ata_smart_values * sv, uint64_t num_sectors); + +int ataWriteSelectiveSelfTestLog(ata_device * device, ata_selective_selftest_args & args, + const ata_smart_values * sv, uint64_t num_sectors, + const ata_selective_selftest_args * prev_spans = 0); + +// Get World Wide Name (WWN) fields. +// Return NAA field or -1 if WWN is unsupported. +int ata_get_wwn(const ata_identify_device * id, unsigned & oui, uint64_t & unique_id); + +// Get nominal media rotation rate. +// Returns: 0 = not reported, 1 = SSD, >1 = HDD rpm, < 0 = -(Unknown value) +int ata_get_rotation_rate(const ata_identify_device * id); + +// If SMART supported, this is guaranteed to return 1 if SMART is enabled, else 0. +int ataDoesSmartWork(ata_device * device); + +// returns 1 if SMART supported, 0 if not supported or can't tell +int ataSmartSupport(const ata_identify_device * drive); + +// Return values: +// 1: Write Cache Reordering enabled +// 2: Write Cache Reordering disabled +// -1: error +int ataGetSetSCTWriteCacheReordering(ata_device * device, bool enable, bool persistent, bool set); + +// Return values: +// 1: Write cache controlled by ATA Set Features command +// 2: Force enable write cache +// 3: Force disable write cache +int ataGetSetSCTWriteCache(ata_device * device, unsigned short state, bool persistent, bool set); + +// Return values: +// 1: SMART enabled +// 0: SMART disabled +// -1: can't tell if SMART is enabled -- try issuing ataDoesSmartWork command to see +int ataIsSmartEnabled(const ata_identify_device * drive); + +int ataSmartStatus2(ata_device * device); + +bool isSmartErrorLogCapable(const ata_smart_values * data, const ata_identify_device * identity); + +bool isSmartTestLogCapable(const ata_smart_values * data, const ata_identify_device * identity); + +bool isGeneralPurposeLoggingCapable(const ata_identify_device * identity); + +// SMART self-test capability is also indicated in bit 1 of DEVICE +// IDENTIFY word 87 (if top two bits of word 87 match pattern 01). +// However this was only introduced in ATA-6 (but self-test log was in +// ATA-5). +inline bool isSupportExecuteOfflineImmediate(const ata_smart_values *data) + { return !!(data->offline_data_collection_capability & 0x01); } + +// TODO: Remove uses of this check. Bit 1 is vendor specific since ATA-4. +// Automatic timer support was only documented for very old IBM drives +// (for example IBM Travelstar 40GNX). +inline bool isSupportAutomaticTimer(const ata_smart_values * data) + { return !!(data->offline_data_collection_capability & 0x02); } + +inline bool isSupportOfflineAbort(const ata_smart_values *data) + { return !!(data->offline_data_collection_capability & 0x04); } + +inline bool isSupportOfflineSurfaceScan(const ata_smart_values * data) + { return !!(data->offline_data_collection_capability & 0x08); } + +inline bool isSupportSelfTest(const ata_smart_values * data) + { return !!(data->offline_data_collection_capability & 0x10); } + +inline bool isSupportConveyanceSelfTest(const ata_smart_values * data) + { return !!(data->offline_data_collection_capability & 0x20); } + +inline bool isSupportSelectiveSelfTest(const ata_smart_values * data) + { return !!(data->offline_data_collection_capability & 0x40); } + +inline bool isSCTCapable(const ata_identify_device *drive) + { return !!(drive->words088_255[206-88] & 0x01); } // 0x01 = SCT support + +inline bool isSCTErrorRecoveryControlCapable(const ata_identify_device *drive) + { return ((drive->words088_255[206-88] & 0x09) == 0x09); } // 0x08 = SCT Error Recovery Control support + +inline bool isSCTFeatureControlCapable(const ata_identify_device *drive) + { return ((drive->words088_255[206-88] & 0x11) == 0x11); } // 0x10 = SCT Feature Control support + +inline bool isSCTDataTableCapable(const ata_identify_device *drive) + { return ((drive->words088_255[206-88] & 0x21) == 0x21); } // 0x20 = SCT Data Table support + +int TestTime(const ata_smart_values * data, int testtype); + +// Attribute state +enum ata_attr_state +{ + ATTRSTATE_NON_EXISTING, // No such Attribute + ATTRSTATE_NO_NORMVAL, // Normalized value not valid + ATTRSTATE_NO_THRESHOLD, // Unknown or no threshold + ATTRSTATE_OK, // Never failed + ATTRSTATE_FAILED_PAST, // Failed in the past + ATTRSTATE_FAILED_NOW // Failed now +}; + +// Get attribute state +ata_attr_state ata_get_attr_state(const ata_smart_attribute & attr, + int attridx, + const ata_smart_threshold_entry * thresholds, + const ata_vendor_attr_defs & defs, + unsigned char * threshval = 0); + +// Get attribute raw value. +uint64_t ata_get_attr_raw_value(const ata_smart_attribute & attr, + const ata_vendor_attr_defs & defs); + +// Format attribute raw value. +std::string ata_format_attr_raw_value(const ata_smart_attribute & attr, + const ata_vendor_attr_defs & defs); + +// Get attribute name +std::string ata_get_smart_attr_name(unsigned char id, + const ata_vendor_attr_defs & defs, + int rpm = 0); + +// External handler function, for when a checksum is not correct. Can +// simply return if no action is desired, or can print error messages +// as needed, or exit. Is passed a string with the name of the Data +// Structure with the incorrect checksum. +void checksumwarning(const char *string); + +// Find attribute index for attribute id, -1 if not found. +int ata_find_attr_index(unsigned char id, const ata_smart_values & smartval); + +// Return Temperature Attribute raw value selected according to possible +// non-default interpretations. If the Attribute does not exist, return 0 +unsigned char ata_return_temperature_value(const ata_smart_values * data, const ata_vendor_attr_defs & defs); + + +#define MAX_ATTRIBUTE_NUM 256 + +// Parse vendor attribute display def (-v option). +// Return false on error. +bool parse_attribute_def(const char * opt, ata_vendor_attr_defs & defs, + ata_vendor_def_prior priority); + +// Get ID and increase flag of current pending or offline +// uncorrectable attribute. +unsigned char get_unc_attr_id(bool offline, const ata_vendor_attr_defs & defs, + bool & increase); + +// Return a multiline string containing a list of valid arguments for +// parse_attribute_def(). +std::string create_vendor_attribute_arg_list(); + +// Parse firmwarebug def (-F option). +// Return false on error. +bool parse_firmwarebug_def(const char * opt, firmwarebug_defs & firmwarebugs); + +// Return a string of valid argument words for parse_firmwarebug_def() +const char * get_valid_firmwarebug_args(); + + +// These are two of the functions that are defined in os_*.c and need +// to be ported to get smartmontools onto another OS. +// Moved to C++ interface +//int ata_command_interface(int device, smart_command_set command, int select, char *data); +//int escalade_command_interface(int fd, int escalade_port, int escalade_type, smart_command_set command, int select, char *data); +//int marvell_command_interface(int device, smart_command_set command, int select, char *data); +//int highpoint_command_interface(int device, smart_command_set command, int select, char *data); +//int areca_command_interface(int fd, int disknum, smart_command_set command, int select, char *data); + + +// This function is exported to give low-level capability +int smartcommandhandler(ata_device * device, smart_command_set command, int select, char *data); + +// Get capacity and sector sizes from IDENTIFY data +struct ata_size_info +{ + uint64_t sectors; + uint64_t capacity; + unsigned log_sector_size; + unsigned phy_sector_size; + unsigned log_sector_offset; +}; + +void ata_get_size_info(const ata_identify_device * id, ata_size_info & sizes); + +// Convenience function for formatting strings from ata_identify_device. +void ata_format_id_string(char * out, const unsigned char * in, int n); + +// Utility routines. +unsigned char checksum(const void * data); + +// Return pseudo-device to parse "smartctl -r ataioctl,2 ..." output +// and simulate an ATA device with same behaviour +ata_device * get_parsed_ata_device(smart_interface * intf, const char * dev_name); + +#endif /* ATACMDS_H_ */ |