4 * Home page of code is: http://smartmontools.sourceforge.net
6 * Copyright (C) 2002-11 Bruce Allen <smartmontools-support@lists.sourceforge.net>
7 * Copyright (C) 2008-12 Christian Franke <smartmontools-support@lists.sourceforge.net>
8 * Copyright (C) 1999-2000 Michael Cornwell <cornwell@acm.org>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2, or (at your option)
15 * You should have received a copy of the GNU General Public License
16 * (for example COPYING); if not, write to the Free
17 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 * This code was originally developed as a Senior Thesis by Michael Cornwell
20 * at the Concurrent Systems Laboratory (now part of the Storage Systems
21 * Research Center), Jack Baskin School of Engineering, University of
22 * California, Santa Cruz. http://ssrc.soe.ucsc.edu/
29 #define ATACMDS_H_CVSID "$Id: atacmds.h 3528 2012-03-25 17:13:47Z chrfranke $"
31 #include "dev_interface.h" // ata_device
33 // Macro to check expected size of struct at compile time using a
34 // dummy typedef. On size mismatch, compiler reports a negative array
35 // size. If you see an error message of this form, it means that the
36 // #pragma pack(1) pragma below is not having the desired effect on
38 #define ASSERT_SIZEOF_STRUCT(s, n) \
39 typedef char assert_sizeof_struct_##s[(sizeof(struct s) == (n)) ? 1 : -1]
41 // Add __attribute__((packed)) if compiler supports it
42 // because some gcc versions (at least ARM) lack support of #pragma pack()
43 #ifdef HAVE_ATTR_PACKED
44 #define ATTR_PACKED __attribute__((packed))
50 // returns no data, just succeeds or fails
56 STATUS
, // just says if SMART is working or not
57 STATUS_CHECK
, // says if disk's SMART status is healthy, or failing
58 // return 512 bytes of data:
64 // returns 1 byte of data
66 // writes 512 bytes of data:
70 // Possible values for fix_firmwarebug.
79 // ATA Specification Command Register Values (Commands)
80 #define ATA_CHECK_POWER_MODE 0xe5
81 #define ATA_IDENTIFY_DEVICE 0xec
82 #define ATA_IDENTIFY_PACKET_DEVICE 0xa1
84 #define ATA_SMART_CMD 0xb0
85 #define ATA_SECURITY_FREEZE_LOCK 0xf5
86 #define ATA_SET_FEATURES 0xef
87 #define ATA_STANDBY_IMMEDIATE 0xe0
89 // SET_FEATURES subcommands
90 #define ATA_DISABLE_AAM 0xc2
91 #define ATA_DISABLE_APM 0x85
92 #define ATA_DISABLE_WRITE_CACHE 0x82
93 #define ATA_DISABLE_READ_LOOK_AHEAD 0x55
94 #define ATA_ENABLE_AAM 0x42
95 #define ATA_ENABLE_APM 0x05
96 #define ATA_ENABLE_WRITE_CACHE 0x02
97 #define ATA_ENABLE_READ_LOOK_AHEAD 0xaa
100 #define ATA_READ_LOG_EXT 0x2F
102 // ATA Specification Feature Register Values (SMART Subcommands).
103 // Note that some are obsolete as of ATA-7.
104 #define ATA_SMART_READ_VALUES 0xd0
105 #define ATA_SMART_READ_THRESHOLDS 0xd1
106 #define ATA_SMART_AUTOSAVE 0xd2
107 #define ATA_SMART_SAVE 0xd3
108 #define ATA_SMART_IMMEDIATE_OFFLINE 0xd4
109 #define ATA_SMART_READ_LOG_SECTOR 0xd5
110 #define ATA_SMART_WRITE_LOG_SECTOR 0xd6
111 #define ATA_SMART_WRITE_THRESHOLDS 0xd7
112 #define ATA_SMART_ENABLE 0xd8
113 #define ATA_SMART_DISABLE 0xd9
114 #define ATA_SMART_STATUS 0xda
115 // SFF 8035i Revision 2 Specification Feature Register Value (SMART
117 #define ATA_SMART_AUTO_OFFLINE 0xdb
119 // Sector Number values for ATA_SMART_IMMEDIATE_OFFLINE Subcommand
120 #define OFFLINE_FULL_SCAN 0
121 #define SHORT_SELF_TEST 1
122 #define EXTEND_SELF_TEST 2
123 #define CONVEYANCE_SELF_TEST 3
124 #define SELECTIVE_SELF_TEST 4
125 #define ABORT_SELF_TEST 127
126 #define SHORT_CAPTIVE_SELF_TEST 129
127 #define EXTEND_CAPTIVE_SELF_TEST 130
128 #define CONVEYANCE_CAPTIVE_SELF_TEST 131
129 #define SELECTIVE_CAPTIVE_SELF_TEST 132
130 #define CAPTIVE_MASK (0x01<<7)
132 // Maximum allowed number of SMART Attributes
133 #define NUMBER_ATA_SMART_ATTRIBUTES 30
135 // Needed parts of the ATA DRIVE IDENTIFY Structure. Those labeled
136 // word* are NOT used.
138 struct ata_identify_device
{
139 unsigned short words000_009
[10];
140 unsigned char serial_no
[20];
141 unsigned short words020_022
[3];
142 unsigned char fw_rev
[8];
143 unsigned char model
[40];
144 unsigned short words047_079
[33];
145 unsigned short major_rev_num
;
146 unsigned short minor_rev_num
;
147 unsigned short command_set_1
;
148 unsigned short command_set_2
;
149 unsigned short command_set_extension
;
150 unsigned short cfs_enable_1
;
151 unsigned short word086
;
152 unsigned short csf_default
;
153 unsigned short words088_255
[168];
156 ASSERT_SIZEOF_STRUCT(ata_identify_device
, 512);
158 /* ata_smart_attribute is the vendor specific in SFF-8035 spec */
160 struct ata_smart_attribute
{
162 // meaning of flag bits: see MACROS just below
163 // WARNING: MISALIGNED!
164 unsigned short flags
;
165 unsigned char current
;
167 unsigned char raw
[6];
168 unsigned char reserv
;
171 ASSERT_SIZEOF_STRUCT(ata_smart_attribute
, 12);
173 // MACROS to interpret the flags bits in the previous structure.
174 // These have not been implemented using bitflags and a union, to make
175 // it portable across bit/little endian and different platforms.
179 // From SFF 8035i Revision 2 page 19: Bit 0 (pre-failure/advisory bit)
180 // - If the value of this bit equals zero, an attribute value less
181 // than or equal to its corresponding attribute threshold indicates an
182 // advisory condition where the usage or age of the device has
183 // exceeded its intended design life period. If the value of this bit
184 // equals one, an attribute value less than or equal to its
185 // corresponding attribute threshold indicates a prefailure condition
186 // where imminent loss of data is being predicted.
187 #define ATTRIBUTE_FLAGS_PREFAILURE(x) (x & 0x01)
191 // From SFF 8035i Revision 2 page 19: Bit 1 (on-line data collection
192 // bit) - If the value of this bit equals zero, then the attribute
193 // value is updated only during off-line data collection
194 // activities. If the value of this bit equals one, then the attribute
195 // value is updated during normal operation of the device or during
196 // both normal operation and off-line testing.
197 #define ATTRIBUTE_FLAGS_ONLINE(x) (x & 0x02)
200 // The following are (probably) IBM's, Maxtors and Quantum's definitions for the
201 // vendor-specific bits:
202 // 2: Performance type bit
203 #define ATTRIBUTE_FLAGS_PERFORMANCE(x) (x & 0x04)
205 // 3: Errorrate type bit
206 #define ATTRIBUTE_FLAGS_ERRORRATE(x) (x & 0x08)
209 #define ATTRIBUTE_FLAGS_EVENTCOUNT(x) (x & 0x10)
211 // 5: Selfpereserving bit
212 #define ATTRIBUTE_FLAGS_SELFPRESERVING(x) (x & 0x20)
214 // 6-15: Reserved for future use
215 #define ATTRIBUTE_FLAGS_OTHER(x) ((x) & 0xffc0)
218 // Format of data returned by SMART READ DATA
219 // Table 62 of T13/1699-D (ATA8-ACS) Revision 6a, September 2008
221 struct ata_smart_values
{
222 unsigned short int revnumber
;
223 struct ata_smart_attribute vendor_attributes
[NUMBER_ATA_SMART_ATTRIBUTES
];
224 unsigned char offline_data_collection_status
;
225 unsigned char self_test_exec_status
; //IBM # segments for offline collection
226 unsigned short int total_time_to_complete_off_line
; // IBM different
227 unsigned char vendor_specific_366
; // Maxtor & IBM curent segment pointer
228 unsigned char offline_data_collection_capability
;
229 unsigned short int smart_capability
;
230 unsigned char errorlog_capability
;
231 unsigned char vendor_specific_371
; // Maxtor, IBM: self-test failure checkpoint see below!
232 unsigned char short_test_completion_time
;
233 unsigned char extend_test_completion_time_b
; // If 0xff, use 16-bit value below
234 unsigned char conveyance_test_completion_time
;
235 unsigned short extend_test_completion_time_w
; // e04130r2, added to T13/1699-D Revision 1c, April 2005
236 unsigned char reserved_377_385
[9];
237 unsigned char vendor_specific_386_510
[125]; // Maxtor bytes 508-509 Attribute/Threshold Revision #
238 unsigned char chksum
;
241 ASSERT_SIZEOF_STRUCT(ata_smart_values
, 512);
243 /* Maxtor, IBM: self-test failure checkpoint byte meaning:
252 /* Vendor attribute of SMART Threshold (compare to ata_smart_attribute above) */
254 struct ata_smart_threshold_entry
{
256 unsigned char threshold
;
257 unsigned char reserved
[10];
260 ASSERT_SIZEOF_STRUCT(ata_smart_threshold_entry
, 12);
262 /* Format of Read SMART THreshold Command */
263 /* Compare to ata_smart_values above */
265 struct ata_smart_thresholds_pvt
{
266 unsigned short int revnumber
;
267 struct ata_smart_threshold_entry thres_entries
[NUMBER_ATA_SMART_ATTRIBUTES
];
268 unsigned char reserved
[149];
269 unsigned char chksum
;
272 ASSERT_SIZEOF_STRUCT(ata_smart_thresholds_pvt
, 512);
275 // Table 42 of T13/1321D Rev 1 spec (Error Data Structure)
277 struct ata_smart_errorlog_error_struct
{
278 unsigned char reserved
;
279 unsigned char error_register
;
280 unsigned char sector_count
;
281 unsigned char sector_number
;
282 unsigned char cylinder_low
;
283 unsigned char cylinder_high
;
284 unsigned char drive_head
;
285 unsigned char status
;
286 unsigned char extended_error
[19];
288 unsigned short timestamp
;
291 ASSERT_SIZEOF_STRUCT(ata_smart_errorlog_error_struct
, 30);
294 // Table 41 of T13/1321D Rev 1 spec (Command Data Structure)
296 struct ata_smart_errorlog_command_struct
{
297 unsigned char devicecontrolreg
;
298 unsigned char featuresreg
;
299 unsigned char sector_count
;
300 unsigned char sector_number
;
301 unsigned char cylinder_low
;
302 unsigned char cylinder_high
;
303 unsigned char drive_head
;
304 unsigned char commandreg
;
305 unsigned int timestamp
;
308 ASSERT_SIZEOF_STRUCT(ata_smart_errorlog_command_struct
, 12);
310 // Table 40 of T13/1321D Rev 1 spec (Error log data structure)
312 struct ata_smart_errorlog_struct
{
313 struct ata_smart_errorlog_command_struct commands
[5];
314 struct ata_smart_errorlog_error_struct error_struct
;
317 ASSERT_SIZEOF_STRUCT(ata_smart_errorlog_struct
, 90);
319 // Table 39 of T13/1321D Rev 1 spec (SMART error log sector)
321 struct ata_smart_errorlog
{
322 unsigned char revnumber
;
323 unsigned char error_log_pointer
;
324 struct ata_smart_errorlog_struct errorlog_struct
[5];
325 unsigned short int ata_error_count
;
326 unsigned char reserved
[57];
327 unsigned char checksum
;
330 ASSERT_SIZEOF_STRUCT(ata_smart_errorlog
, 512);
333 // Extended Comprehensive SMART Error Log data structures
334 // See Section A.7 of
335 // AT Attachment 8 - ATA/ATAPI Command Set (ATA8-ACS)
336 // T13/1699-D Revision 6a (Working Draft), September 6, 2008.
338 // Command data structure
339 // Table A.9 of T13/1699-D Revision 6a
341 struct ata_smart_exterrlog_command
343 unsigned char device_control_register
;
344 unsigned char features_register
;
345 unsigned char features_register_hi
;
346 unsigned char count_register
;
347 unsigned char count_register_hi
;
348 unsigned char lba_low_register
;
349 unsigned char lba_low_register_hi
;
350 unsigned char lba_mid_register
;
351 unsigned char lba_mid_register_hi
;
352 unsigned char lba_high_register
;
353 unsigned char lba_high_register_hi
;
354 unsigned char device_register
;
355 unsigned char command_register
;
357 unsigned char reserved
;
358 unsigned int timestamp
;
361 ASSERT_SIZEOF_STRUCT(ata_smart_exterrlog_command
, 18);
363 // Error data structure
364 // Table A.10 T13/1699-D Revision 6a
366 struct ata_smart_exterrlog_error
368 unsigned char device_control_register
;
369 unsigned char error_register
;
370 unsigned char count_register
;
371 unsigned char count_register_hi
;
372 unsigned char lba_low_register
;
373 unsigned char lba_low_register_hi
;
374 unsigned char lba_mid_register
;
375 unsigned char lba_mid_register_hi
;
376 unsigned char lba_high_register
;
377 unsigned char lba_high_register_hi
;
378 unsigned char device_register
;
379 unsigned char status_register
;
381 unsigned char extended_error
[19];
383 unsigned short timestamp
;
386 ASSERT_SIZEOF_STRUCT(ata_smart_exterrlog_error
, 34);
388 // Error log data structure
389 // Table A.8 of T13/1699-D Revision 6a
391 struct ata_smart_exterrlog_error_log
393 ata_smart_exterrlog_command commands
[5];
394 ata_smart_exterrlog_error error
;
397 ASSERT_SIZEOF_STRUCT(ata_smart_exterrlog_error_log
, 124);
399 // Ext. Comprehensive SMART error log
400 // Table A.7 of T13/1699-D Revision 6a
402 struct ata_smart_exterrlog
404 unsigned char version
;
405 unsigned char reserved1
;
406 unsigned short error_log_index
;
407 ata_smart_exterrlog_error_log error_logs
[4];
408 unsigned short device_error_count
;
409 unsigned char reserved2
[9];
410 unsigned char checksum
;
413 ASSERT_SIZEOF_STRUCT(ata_smart_exterrlog
, 512);
416 // Table 45 of T13/1321D Rev 1 spec (Self-test log descriptor entry)
418 struct ata_smart_selftestlog_struct
{
419 unsigned char selftestnumber
; // Sector number register
420 unsigned char selfteststatus
;
421 unsigned short int timestamp
;
422 unsigned char selftestfailurecheckpoint
;
423 unsigned int lbafirstfailure
;
424 unsigned char vendorspecific
[15];
427 ASSERT_SIZEOF_STRUCT(ata_smart_selftestlog_struct
, 24);
429 // Table 44 of T13/1321D Rev 1 spec (Self-test log data structure)
431 struct ata_smart_selftestlog
{
432 unsigned short int revnumber
;
433 struct ata_smart_selftestlog_struct selftest_struct
[21];
434 unsigned char vendorspecific
[2];
435 unsigned char mostrecenttest
;
436 unsigned char reserved
[2];
437 unsigned char chksum
;
440 ASSERT_SIZEOF_STRUCT(ata_smart_selftestlog
, 512);
442 // Extended SMART Self-test log data structures
443 // See Section A.8 of
444 // AT Attachment 8 - ATA/ATAPI Command Set (ATA8-ACS)
445 // T13/1699-D Revision 6a (Working Draft), September 6, 2008.
447 // Extended Self-test log descriptor entry
448 // Table A.13 of T13/1699-D Revision 6a
450 struct ata_smart_extselftestlog_desc
452 unsigned char self_test_type
;
453 unsigned char self_test_status
;
454 unsigned short timestamp
;
455 unsigned char checkpoint
;
456 unsigned char failing_lba
[6];
457 unsigned char vendorspecific
[15];
460 ASSERT_SIZEOF_STRUCT(ata_smart_extselftestlog_desc
, 26);
462 // Extended Self-test log data structure
463 // Table A.12 of T13/1699-D Revision 6a
465 struct ata_smart_extselftestlog
467 unsigned char version
;
468 unsigned char reserved1
;
469 unsigned short log_desc_index
;
470 struct ata_smart_extselftestlog_desc log_descs
[19];
471 unsigned char vendor_specifc
[2];
472 unsigned char reserved2
[11];
473 unsigned char chksum
;
476 ASSERT_SIZEOF_STRUCT(ata_smart_extselftestlog
, 512);
478 // SMART LOG DIRECTORY Table 52 of T13/1532D Vol 1 Rev 1a
480 struct ata_smart_log_entry
{
481 unsigned char numsectors
;
482 unsigned char reserved
;
485 ASSERT_SIZEOF_STRUCT(ata_smart_log_entry
, 2);
488 struct ata_smart_log_directory
{
489 unsigned short int logversion
;
490 struct ata_smart_log_entry entry
[255];
493 ASSERT_SIZEOF_STRUCT(ata_smart_log_directory
, 512);
495 // SMART SELECTIVE SELF-TEST LOG Table 61 of T13/1532D Volume 1
503 ASSERT_SIZEOF_STRUCT(test_span
, 16);
506 struct ata_selective_self_test_log
{
507 unsigned short logversion
;
508 struct test_span span
[5];
509 unsigned char reserved1
[337-82+1];
510 unsigned char vendor_specific1
[491-338+1];
512 unsigned short currentspan
;
513 unsigned short flags
;
514 unsigned char vendor_specific2
[507-504+1];
515 unsigned short pendingtime
;
516 unsigned char reserved2
;
517 unsigned char checksum
;
520 ASSERT_SIZEOF_STRUCT(ata_selective_self_test_log
, 512);
522 #define SELECTIVE_FLAG_DOSCAN (0x0002)
523 #define SELECTIVE_FLAG_PENDING (0x0008)
524 #define SELECTIVE_FLAG_ACTIVE (0x0010)
527 // SCT (SMART Command Transport) data structures
528 // See Sections 8.2 and 8.3 of:
529 // AT Attachment 8 - ATA/ATAPI Command Set (ATA8-ACS)
530 // T13/1699-D Revision 3f (Working Draft), December 11, 2006.
532 // SCT Status response (read with SMART_READ_LOG page 0xe0)
533 // Table 60 of T13/1699-D Revision 3f
535 struct ata_sct_status_response
537 unsigned short format_version
; // 0-1: Status response format version number (2, 3)
538 unsigned short sct_version
; // 2-3: Vendor specific version number
539 unsigned short sct_spec
; // 4-5: SCT level supported (1)
540 unsigned int status_flags
; // 6-9: Status flags (Bit 0: Segment initialized, Bits 1-31: reserved)
541 unsigned char device_state
; // 10: Device State (0-5)
542 unsigned char bytes011_013
[3]; // 11-13: reserved
543 unsigned short ext_status_code
; // 14-15: Status of last SCT command (0xffff if executing)
544 unsigned short action_code
; // 16-17: Action code of last SCT command
545 unsigned short function_code
; // 18-19: Function code of last SCT command
546 unsigned char bytes020_039
[20]; // 20-39: reserved
547 uint64_t lba_current
; // 40-47: LBA of SCT command executing in background
548 unsigned char bytes048_199
[152]; // 48-199: reserved
549 signed char hda_temp
; // 200: Current temperature in Celsius (0x80 = invalid)
550 signed char min_temp
; // 201: Minimum temperature this power cycle
551 signed char max_temp
; // 202: Maximum temperature this power cycle
552 signed char life_min_temp
; // 203: Minimum lifetime temperature
553 signed char life_max_temp
; // 204: Maximum lifetime temperature
554 unsigned char byte205
; // 205: reserved (T13/e06152r0-2: Average lifetime temperature)
555 unsigned int over_limit_count
; // 206-209: # intervals since last reset with temperature > Max Op Limit
556 unsigned int under_limit_count
; // 210-213: # intervals since last reset with temperature < Min Op Limit
557 unsigned char bytes214_479
[266]; // 214-479: reserved
558 unsigned char vendor_specific
[32];// 480-511: vendor specific
561 ASSERT_SIZEOF_STRUCT(ata_sct_status_response
, 512);
563 // SCT Error Recovery Control command (send with SMART_WRITE_LOG page 0xe0)
564 // Table 88 of T13/1699-D Revision 6a
566 struct ata_sct_error_recovery_control_command
568 unsigned short action_code
; // 3 = Error Recovery Control
569 unsigned short function_code
; // 1 = Set, 2 = Return
570 unsigned short selection_code
; // 1 = Read Timer, 2 = Write Timer
571 unsigned short time_limit
; // If set: Recovery time limit in 100ms units
572 unsigned short words004_255
[252]; // reserved
575 ASSERT_SIZEOF_STRUCT(ata_sct_error_recovery_control_command
, 512);
577 // SCT Feature Control command (send with SMART_WRITE_LOG page 0xe0)
578 // Table 72 of T13/1699-D Revision 3f
580 struct ata_sct_feature_control_command
582 unsigned short action_code
; // 4 = Feature Control
583 unsigned short function_code
; // 1 = Set, 2 = Return, 3 = Return options
584 unsigned short feature_code
; // 3 = Temperature logging interval
585 unsigned short state
; // Interval
586 unsigned short option_flags
; // Bit 0: persistent, Bits 1-15: reserved
587 unsigned short words005_255
[251]; // reserved
590 ASSERT_SIZEOF_STRUCT(ata_sct_feature_control_command
, 512);
592 // SCT Data Table command (send with SMART_WRITE_LOG page 0xe0)
593 // Table 73 of T13/1699-D Revision 3f
595 struct ata_sct_data_table_command
597 unsigned short action_code
; // 5 = Data Table
598 unsigned short function_code
; // 1 = Read Table
599 unsigned short table_id
; // 2 = Temperature History
600 unsigned short words003_255
[253]; // reserved
603 ASSERT_SIZEOF_STRUCT(ata_sct_data_table_command
, 512);
605 // SCT Temperature History Table (read with SMART_READ_LOG page 0xe1)
606 // Table 75 of T13/1699-D Revision 3f
608 struct ata_sct_temperature_history_table
610 unsigned short format_version
; // 0-1: Data table format version number (2)
611 unsigned short sampling_period
; // 2-3: Temperature sampling period in minutes
612 unsigned short interval
; // 4-5: Timer interval between history entries
613 signed char max_op_limit
; // 6: Maximum recommended continuous operating temperature
614 signed char over_limit
; // 7: Maximum temperature limit
615 signed char min_op_limit
; // 8: Minimum recommended continuous operating limit
616 signed char under_limit
; // 9: Minimum temperature limit
617 unsigned char bytes010_029
[20]; // 10-29: reserved
618 unsigned short cb_size
; // 30-31: Number of history entries (range 128-478)
619 unsigned short cb_index
; // 32-33: Index of last updated entry (zero-based)
620 signed char cb
[478]; // 34-(34+cb_size-1): Circular buffer of temperature values
623 ASSERT_SIZEOF_STRUCT(ata_sct_temperature_history_table
, 512);
625 // Possible values for span_args.mode
627 SEL_RANGE
, // MIN-MAX
628 SEL_REDO
, // redo this
629 SEL_NEXT
, // do next range
630 SEL_CONT
// redo or next depending of last test status
633 // Arguments for selective self-test
634 struct ata_selective_selftest_args
636 // Arguments for each span
639 uint64_t start
; // First block
640 uint64_t end
; // Last block
641 int mode
; // SEL_*, see above
644 : start(0), end(0), mode(SEL_RANGE
) { }
647 span_args span
[5]; // Range and mode for 5 spans
648 int num_spans
; // Number of spans
649 int pending_time
; // One plus time in minutes to wait after powerup before restarting
650 // interrupted offline scan after selective self-test.
651 int scan_after_select
; // Run offline scan after selective self-test:
653 // 1: turn off scan after selective self-test,
654 // 2: turn on scan after selective self-test.
656 ata_selective_selftest_args()
657 : num_spans(0), pending_time(0), scan_after_select(0) { }
660 // Priority for vendor attribute defs
661 enum ata_vendor_def_prior
668 // Raw attribute value print formats
669 enum ata_attr_raw_format
680 RAWFMT_RAW16_OPT_RAW16
,
681 RAWFMT_RAW16_OPT_AVG16
,
682 RAWFMT_RAW24_OPT_RAW8
,
683 RAWFMT_RAW24_DIV_RAW24
,
684 RAWFMT_RAW24_DIV_RAW32
,
688 RAWFMT_MSEC24_HOUR32
,
695 ATTRFLAG_INCREASING
= 0x01, // Value not reset (for reallocated/pending counts)
696 ATTRFLAG_NO_NORMVAL
= 0x02, // Normalized value not valid
697 ATTRFLAG_NO_WORSTVAL
= 0x04 // Worst value not valid
700 // Vendor attribute display defs for all attribute ids
701 class ata_vendor_attr_defs
706 std::string name
; // Attribute name, empty for default
707 ata_attr_raw_format raw_format
; // Raw value print format
708 ata_vendor_def_prior priority
; // Setting priority
709 unsigned flags
; // ATTRFLAG_*
710 char byteorder
[8+1]; // String [012345rvwz] to define byte order
713 : raw_format(RAWFMT_DEFAULT
),
714 priority(PRIOR_DEFAULT
),
716 { byteorder
[0] = 0; }
719 entry
& operator[](unsigned char id
)
720 { return m_defs
[id
]; }
722 const entry
& operator[](unsigned char id
) const
723 { return m_defs
[id
]; }
730 // Print ATA debug messages?
731 extern unsigned char ata_debugmode
;
733 // Suppress serial number?
734 extern bool dont_print_serial_number
;
736 // Get information from drive
737 int ata_read_identity(ata_device
* device
, ata_identify_device
* buf
, bool fix_swapped_id
);
738 int ataCheckPowerMode(ata_device
* device
);
740 // Issue a no-data ATA command with optional sector count register value
741 bool ata_nodata_command(ata_device
* device
, unsigned char command
, int sector_count
= -1);
743 // Issue SET FEATURES command with optional sector count register value
744 bool ata_set_features(ata_device
* device
, unsigned char features
, int sector_count
= -1);
746 /* Read S.M.A.R.T information from drive */
747 int ataReadSmartValues(ata_device
* device
,struct ata_smart_values
*);
748 int ataReadSmartThresholds(ata_device
* device
, struct ata_smart_thresholds_pvt
*);
749 int ataReadErrorLog (ata_device
* device
, ata_smart_errorlog
*data
,
750 unsigned char fix_firmwarebug
);
751 int ataReadSelfTestLog(ata_device
* device
, ata_smart_selftestlog
* data
,
752 unsigned char fix_firmwarebug
);
753 int ataReadSelectiveSelfTestLog(ata_device
* device
, struct ata_selective_self_test_log
*data
);
754 int ataSetSmartThresholds(ata_device
* device
, struct ata_smart_thresholds_pvt
*);
755 int ataReadLogDirectory(ata_device
* device
, ata_smart_log_directory
*, bool gpl
);
757 // Read GP Log page(s)
758 bool ataReadLogExt(ata_device
* device
, unsigned char logaddr
,
759 unsigned char features
, unsigned page
,
760 void * data
, unsigned nsectors
);
761 // Read SMART Log page(s)
762 bool ataReadSmartLog(ata_device
* device
, unsigned char logaddr
,
763 void * data
, unsigned nsectors
);
764 // Read SMART Extended Comprehensive Error Log
765 bool ataReadExtErrorLog(ata_device
* device
, ata_smart_exterrlog
* log
,
767 // Read SMART Extended Self-test Log
768 bool ataReadExtSelfTestLog(ata_device
* device
, ata_smart_extselftestlog
* log
,
771 // Read SCT information
772 int ataReadSCTStatus(ata_device
* device
, ata_sct_status_response
* sts
);
773 int ataReadSCTTempHist(ata_device
* device
, ata_sct_temperature_history_table
* tmh
,
774 ata_sct_status_response
* sts
);
775 // Set SCT temperature logging interval
776 int ataSetSCTTempInterval(ata_device
* device
, unsigned interval
, bool persistent
);
778 // Get/Set SCT Error Recovery Control
779 int ataGetSCTErrorRecoveryControltime(ata_device
* device
, unsigned type
, unsigned short & time_limit
);
780 int ataSetSCTErrorRecoveryControltime(ata_device
* device
, unsigned type
, unsigned short time_limit
);
783 /* Enable/Disable SMART on device */
784 int ataEnableSmart (ata_device
* device
);
785 int ataDisableSmart (ata_device
* device
);
786 int ataEnableAutoSave(ata_device
* device
);
787 int ataDisableAutoSave(ata_device
* device
);
789 /* Automatic Offline Testing */
790 int ataEnableAutoOffline (ata_device
* device
);
791 int ataDisableAutoOffline (ata_device
* device
);
793 /* S.M.A.R.T. test commands */
794 int ataSmartTest(ata_device
* device
, int testtype
, bool force
,
795 const ata_selective_selftest_args
& args
,
796 const ata_smart_values
* sv
, uint64_t num_sectors
);
798 int ataWriteSelectiveSelfTestLog(ata_device
* device
, ata_selective_selftest_args
& args
,
799 const ata_smart_values
* sv
, uint64_t num_sectors
,
800 const ata_selective_selftest_args
* prev_spans
= 0);
802 // Returns the latest compatibility of ATA/ATAPI Version the device
803 // supports. Returns -1 if Version command is not supported
804 int ataVersionInfo(const char ** description
, const ata_identify_device
* drive
, unsigned short * minor
);
806 // Get World Wide Name (WWN) fields.
807 // Return NAA field or -1 if WWN is unsupported.
808 int ata_get_wwn(const ata_identify_device
* id
, unsigned & oui
, uint64_t & unique_id
);
810 // If SMART supported, this is guaranteed to return 1 if SMART is enabled, else 0.
811 int ataDoesSmartWork(ata_device
* device
);
813 // returns 1 if SMART supported, 0 if not supported or can't tell
814 int ataSmartSupport(const ata_identify_device
* drive
);
819 // -1: can't tell if SMART is enabled -- try issuing ataDoesSmartWork command to see
820 int ataIsSmartEnabled(const ata_identify_device
* drive
);
822 int ataSmartStatus2(ata_device
* device
);
824 int isSmartErrorLogCapable(const ata_smart_values
* data
, const ata_identify_device
* identity
);
826 int isSmartTestLogCapable(const ata_smart_values
* data
, const ata_identify_device
* identity
);
828 int isGeneralPurposeLoggingCapable(const ata_identify_device
* identity
);
830 int isSupportExecuteOfflineImmediate(const ata_smart_values
* data
);
832 int isSupportAutomaticTimer(const ata_smart_values
* data
);
834 int isSupportOfflineAbort(const ata_smart_values
* data
);
836 int isSupportOfflineSurfaceScan(const ata_smart_values
* data
);
838 int isSupportSelfTest(const ata_smart_values
* data
);
840 int isSupportConveyanceSelfTest(const ata_smart_values
* data
);
842 int isSupportSelectiveSelfTest(const ata_smart_values
* data
);
844 inline bool isSCTCapable(const ata_identify_device
*drive
)
845 { return !!(drive
->words088_255
[206-88] & 0x01); } // 0x01 = SCT support
847 inline bool isSCTErrorRecoveryControlCapable(const ata_identify_device
*drive
)
848 { return ((drive
->words088_255
[206-88] & 0x09) == 0x09); } // 0x08 = SCT Error Recovery Control support
850 inline bool isSCTFeatureControlCapable(const ata_identify_device
*drive
)
851 { return ((drive
->words088_255
[206-88] & 0x11) == 0x11); } // 0x10 = SCT Feature Control support
853 inline bool isSCTDataTableCapable(const ata_identify_device
*drive
)
854 { return ((drive
->words088_255
[206-88] & 0x21) == 0x21); } // 0x20 = SCT Data Table support
856 int TestTime(const ata_smart_values
* data
, int testtype
);
861 ATTRSTATE_NON_EXISTING
, // No such Attribute
862 ATTRSTATE_NO_NORMVAL
, // Normalized value not valid
863 ATTRSTATE_NO_THRESHOLD
, // Unknown or no threshold
864 ATTRSTATE_OK
, // Never failed
865 ATTRSTATE_FAILED_PAST
, // Failed in the past
866 ATTRSTATE_FAILED_NOW
// Failed now
869 // Get attribute state
870 ata_attr_state
ata_get_attr_state(const ata_smart_attribute
& attr
,
872 const ata_smart_threshold_entry
* thresholds
,
873 const ata_vendor_attr_defs
& defs
,
874 unsigned char * threshval
= 0);
876 // Get attribute raw value.
877 uint64_t ata_get_attr_raw_value(const ata_smart_attribute
& attr
,
878 const ata_vendor_attr_defs
& defs
);
880 // Format attribute raw value.
881 std::string
ata_format_attr_raw_value(const ata_smart_attribute
& attr
,
882 const ata_vendor_attr_defs
& defs
);
884 // Get attribute name
885 std::string
ata_get_smart_attr_name(unsigned char id
,
886 const ata_vendor_attr_defs
& defs
);
888 // External handler function, for when a checksum is not correct. Can
889 // simply return if no action is desired, or can print error messages
890 // as needed, or exit. Is passed a string with the name of the Data
891 // Structure with the incorrect checksum.
892 void checksumwarning(const char *string
);
894 // Find attribute index for attribute id, -1 if not found.
895 int ata_find_attr_index(unsigned char id
, const ata_smart_values
& smartval
);
897 // Return Temperature Attribute raw value selected according to possible
898 // non-default interpretations. If the Attribute does not exist, return 0
899 unsigned char ata_return_temperature_value(const ata_smart_values
* data
, const ata_vendor_attr_defs
& defs
);
902 // This are the meanings of the Self-test failure checkpoint byte.
903 // This is in the self-test log at offset 4 bytes into the self-test
904 // descriptor and in the SMART READ DATA structure at byte offset
905 // 371. These codes are not well documented. The meanings returned by
906 // this routine are used (at least) by Maxtor and IBM. Returns NULL if
908 const char *SelfTestFailureCodeName(unsigned char which
);
911 #define MAX_ATTRIBUTE_NUM 256
913 // Parse vendor attribute display def (-v option).
914 // Return false on error.
915 bool parse_attribute_def(const char * opt
, ata_vendor_attr_defs
& defs
,
916 ata_vendor_def_prior priority
);
918 // Get ID and increase flag of current pending or offline
919 // uncorrectable attribute.
920 unsigned char get_unc_attr_id(bool offline
, const ata_vendor_attr_defs
& defs
,
923 // Return a multiline string containing a list of valid arguments for
924 // parse_attribute_def().
925 std::string
create_vendor_attribute_arg_list();
928 // These are two of the functions that are defined in os_*.c and need
929 // to be ported to get smartmontools onto another OS.
930 // Moved to C++ interface
931 //int ata_command_interface(int device, smart_command_set command, int select, char *data);
932 //int escalade_command_interface(int fd, int escalade_port, int escalade_type, smart_command_set command, int select, char *data);
933 //int marvell_command_interface(int device, smart_command_set command, int select, char *data);
934 //int highpoint_command_interface(int device, smart_command_set command, int select, char *data);
935 //int areca_command_interface(int fd, int disknum, smart_command_set command, int select, char *data);
938 // Optional functions of os_*.c
939 #ifdef HAVE_ATA_IDENTIFY_IS_CACHED
940 // Return true if OS caches the ATA identify sector
941 //int ata_identify_is_cached(int fd);
944 // This function is exported to give low-level capability
945 int smartcommandhandler(ata_device
* device
, smart_command_set command
, int select
, char *data
);
947 // Print one self-test log entry.
949 // -1: failed self-test
950 // 1: extended self-test completed without error
952 int ataPrintSmartSelfTestEntry(unsigned testnum
, unsigned char test_type
,
953 unsigned char test_status
,
954 unsigned short timestamp
,
955 uint64_t failing_lba
,
956 bool print_error_only
, bool & print_header
);
958 // Print Smart self-test log, used by smartctl and smartd.
959 int ataPrintSmartSelfTestlog(const ata_smart_selftestlog
* data
, bool allentries
,
960 unsigned char fix_firmwarebug
);
962 // Get capacity and sector sizes from IDENTIFY data
967 unsigned log_sector_size
;
968 unsigned phy_sector_size
;
969 unsigned log_sector_offset
;
972 void ata_get_size_info(const ata_identify_device
* id
, ata_size_info
& sizes
);
974 // Convenience function for formatting strings from ata_identify_device.
975 void ata_format_id_string(char * out
, const unsigned char * in
, int n
);
978 unsigned char checksum(const void * data
);
980 void swap2(char *location
);
981 void swap4(char *location
);
982 void swap8(char *location
);
983 // Typesafe variants using overloading
984 inline void swapx(unsigned short * p
)
986 inline void swapx(unsigned int * p
)
988 inline void swapx(uint64_t * p
)
991 // Return pseudo-device to parse "smartctl -r ataioctl,2 ..." output
992 // and simulate an ATA device with same behaviour
993 ata_device
* get_parsed_ata_device(smart_interface
* intf
, const char * dev_name
);
995 #endif /* ATACMDS_H_ */