atacmds.h

   1 /*
   2  * atacmds.h
   3  *
   4  * Home page of code is: http://www.smartmontools.org
   5  *
   6  * Copyright (C) 2002-11 Bruce Allen
   7  * Copyright (C) 2008-15 Christian Franke
   8  * Copyright (C) 1999-2000 Michael Cornwell <cornwell@acm.org>
   9  *
  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)
  13  * any later version.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * (for example COPYING); If not, see <http://www.gnu.org/licenses/>.
  17  *
  18  * This code was originally developed as a Senior Thesis by Michael Cornwell
  19  * at the Concurrent Systems Laboratory (now part of the Storage Systems
  20  * Research Center), Jack Baskin School of Engineering, University of
  21  * California, Santa Cruz. http://ssrc.soe.ucsc.edu/
  22  *
  23  */
  24
  25 #ifndef ATACMDS_H_
  26 #define ATACMDS_H_
  27
  28 #define ATACMDS_H_CVSID "$Id: atacmds.h 4162 2015-10-31 16:36:16Z chrfranke $"
  29
  30 #include "dev_interface.h" // ata_device
  31
  32 // Macro to check expected size of struct at compile time using a
  33 // dummy typedef.  On size mismatch, compiler reports a negative array
  34 // size.  If you see an error message of this form, it means that the
  35 // #pragma pack(1) pragma below is not having the desired effect on
  36 // your compiler.
  37 #define ASSERT_SIZEOF_STRUCT(s, n) \
  38   typedef char assert_sizeof_struct_##s[(sizeof(struct s) == (n)) ? 1 : -1]
  39
  40 // Add __attribute__((packed)) if compiler supports it
  41 // because some gcc versions (at least ARM) lack support of #pragma pack()
  42 #ifdef HAVE_ATTR_PACKED
  43 #define ATTR_PACKED __attribute__((packed))
  44 #else
  45 #define ATTR_PACKED
  46 #endif
  47
  48 typedef enum {
  49   // returns no data, just succeeds or fails
  50   ENABLE,
  51   DISABLE,
  52   AUTOSAVE,
  53   IMMEDIATE_OFFLINE,
  54   AUTO_OFFLINE,
  55   STATUS,       // just says if SMART is working or not
  56   STATUS_CHECK, // says if disk's SMART status is healthy, or failing
  57   // return 512 bytes of data:
  58   READ_VALUES,
  59   READ_THRESHOLDS,
  60   READ_LOG,
  61   IDENTIFY,
  62   PIDENTIFY,
  63   // returns 1 byte of data
  64   CHECK_POWER_MODE,
  65   // writes 512 bytes of data:
  66   WRITE_LOG
  67 } smart_command_set;
  68
  69
  70 // ATA Specification Command Register Values (Commands)
  71 #define ATA_CHECK_POWER_MODE            0xe5
  72 #define ATA_IDENTIFY_DEVICE             0xec
  73 #define ATA_IDENTIFY_PACKET_DEVICE      0xa1
  74 #define ATA_IDLE                        0xe3
  75 #define ATA_SMART_CMD                   0xb0
  76 #define ATA_SECURITY_FREEZE_LOCK        0xf5
  77 #define ATA_SET_FEATURES                0xef
  78 #define ATA_STANDBY_IMMEDIATE           0xe0
  79
  80 // SET_FEATURES subcommands
  81 #define ATA_DISABLE_AAM                 0xc2
  82 #define ATA_DISABLE_APM                 0x85
  83 #define ATA_DISABLE_WRITE_CACHE         0x82
  84 #define ATA_DISABLE_READ_LOOK_AHEAD     0x55
  85 #define ATA_ENABLE_AAM                  0x42
  86 #define ATA_ENABLE_APM                  0x05
  87 #define ATA_ENABLE_WRITE_CACHE          0x02
  88 #define ATA_ENABLE_READ_LOOK_AHEAD      0xaa
  89
  90 // 48-bit commands
  91 #define ATA_READ_LOG_EXT                0x2F
  92
  93 // ATA Specification Feature Register Values (SMART Subcommands).
  94 // Note that some are obsolete as of ATA-7.
  95 #define ATA_SMART_READ_VALUES           0xd0
  96 #define ATA_SMART_READ_THRESHOLDS       0xd1
  97 #define ATA_SMART_AUTOSAVE              0xd2
  98 #define ATA_SMART_SAVE                  0xd3
  99 #define ATA_SMART_IMMEDIATE_OFFLINE     0xd4
 100 #define ATA_SMART_READ_LOG_SECTOR       0xd5
 101 #define ATA_SMART_WRITE_LOG_SECTOR      0xd6
 102 #define ATA_SMART_WRITE_THRESHOLDS      0xd7
 103 #define ATA_SMART_ENABLE                0xd8
 104 #define ATA_SMART_DISABLE               0xd9
 105 #define ATA_SMART_STATUS                0xda
 106 // SFF 8035i Revision 2 Specification Feature Register Value (SMART
 107 // Subcommand)
 108 #define ATA_SMART_AUTO_OFFLINE          0xdb
 109
 110 // Sector Number values for ATA_SMART_IMMEDIATE_OFFLINE Subcommand
 111 #define OFFLINE_FULL_SCAN               0
 112 #define SHORT_SELF_TEST                 1
 113 #define EXTEND_SELF_TEST                2
 114 #define CONVEYANCE_SELF_TEST            3
 115 #define SELECTIVE_SELF_TEST             4
 116 #define ABORT_SELF_TEST                 127
 117 #define SHORT_CAPTIVE_SELF_TEST         129
 118 #define EXTEND_CAPTIVE_SELF_TEST        130
 119 #define CONVEYANCE_CAPTIVE_SELF_TEST    131
 120 #define SELECTIVE_CAPTIVE_SELF_TEST     132
 121 #define CAPTIVE_MASK                    (0x01<<7)
 122
 123 // Maximum allowed number of SMART Attributes
 124 #define NUMBER_ATA_SMART_ATTRIBUTES     30
 125
 126 // Needed parts of the ATA DRIVE IDENTIFY Structure. Those labeled
 127 // word* are NOT used.
 128 #pragma pack(1)
 129 struct ata_identify_device {
 130   unsigned short words000_009[10];
 131   unsigned char  serial_no[20];
 132   unsigned short words020_022[3];
 133   unsigned char  fw_rev[8];
 134   unsigned char  model[40];
 135   unsigned short words047_079[33];
 136   unsigned short major_rev_num;
 137   unsigned short minor_rev_num;
 138   unsigned short command_set_1;
 139   unsigned short command_set_2;
 140   unsigned short command_set_extension;
 141   unsigned short cfs_enable_1;
 142   unsigned short word086;
 143   unsigned short csf_default;
 144   unsigned short words088_255[168];
 145 } ATTR_PACKED;
 146 #pragma pack()
 147 ASSERT_SIZEOF_STRUCT(ata_identify_device, 512);
 148
 149 /* ata_smart_attribute is the vendor specific in SFF-8035 spec */
 150 #pragma pack(1)
 151 struct ata_smart_attribute {
 152   unsigned char id;
 153   // meaning of flag bits: see MACROS just below
 154   // WARNING: MISALIGNED!
 155   unsigned short flags;
 156   unsigned char current;
 157   unsigned char worst;
 158   unsigned char raw[6];
 159   unsigned char reserv;
 160 } ATTR_PACKED;
 161 #pragma pack()
 162 ASSERT_SIZEOF_STRUCT(ata_smart_attribute, 12);
 163
 164 // MACROS to interpret the flags bits in the previous structure.
 165 // These have not been implemented using bitflags and a union, to make
 166 // it portable across bit/little endian and different platforms.
 167
 168 // 0: Prefailure bit
 169
 170 // From SFF 8035i Revision 2 page 19: Bit 0 (pre-failure/advisory bit)
 171 // - If the value of this bit equals zero, an attribute value less
 172 // than or equal to its corresponding attribute threshold indicates an
 173 // advisory condition where the usage or age of the device has
 174 // exceeded its intended design life period. If the value of this bit
 175 // equals one, an attribute value less than or equal to its
 176 // corresponding attribute threshold indicates a prefailure condition
 177 // where imminent loss of data is being predicted.
 178 #define ATTRIBUTE_FLAGS_PREFAILURE(x) (x & 0x01)
 179
 180 // 1: Online bit
 181
 182 //  From SFF 8035i Revision 2 page 19: Bit 1 (on-line data collection
 183 // bit) - If the value of this bit equals zero, then the attribute
 184 // value is updated only during off-line data collection
 185 // activities. If the value of this bit equals one, then the attribute
 186 // value is updated during normal operation of the device or during
 187 // both normal operation and off-line testing.
 188 #define ATTRIBUTE_FLAGS_ONLINE(x) (x & 0x02)
 189
 190
 191 // The following are (probably) IBM's, Maxtors and  Quantum's definitions for the
 192 // vendor-specific bits:
 193 // 2: Performance type bit
 194 #define ATTRIBUTE_FLAGS_PERFORMANCE(x) (x & 0x04)
 195
 196 // 3: Errorrate type bit
 197 #define ATTRIBUTE_FLAGS_ERRORRATE(x) (x & 0x08)
 198
 199 // 4: Eventcount bit
 200 #define ATTRIBUTE_FLAGS_EVENTCOUNT(x) (x & 0x10)
 201
 202 // 5: Selfpereserving bit
 203 #define ATTRIBUTE_FLAGS_SELFPRESERVING(x) (x & 0x20)
 204
 205 // 6-15: Reserved for future use
 206 #define ATTRIBUTE_FLAGS_OTHER(x) ((x) & 0xffc0)
 207
 208
 209 // Format of data returned by SMART READ DATA
 210 // Table 62 of T13/1699-D (ATA8-ACS) Revision 6a, September 2008
 211 #pragma pack(1)
 212 struct ata_smart_values {
 213   unsigned short int revnumber;
 214   struct ata_smart_attribute vendor_attributes [NUMBER_ATA_SMART_ATTRIBUTES];
 215   unsigned char offline_data_collection_status;
 216   unsigned char self_test_exec_status;  //IBM # segments for offline collection
 217   unsigned short int total_time_to_complete_off_line; // IBM different
 218   unsigned char vendor_specific_366; // Maxtor & IBM curent segment pointer
 219   unsigned char offline_data_collection_capability;
 220   unsigned short int smart_capability;
 221   unsigned char errorlog_capability;
 222   unsigned char vendor_specific_371;  // Maxtor, IBM: self-test failure checkpoint see below!
 223   unsigned char short_test_completion_time;
 224   unsigned char extend_test_completion_time_b; // If 0xff, use 16-bit value below
 225   unsigned char conveyance_test_completion_time;
 226   unsigned short extend_test_completion_time_w; // e04130r2, added to T13/1699-D Revision 1c, April 2005
 227   unsigned char reserved_377_385[9];
 228   unsigned char vendor_specific_386_510[125]; // Maxtor bytes 508-509 Attribute/Threshold Revision #
 229   unsigned char chksum;
 230 } ATTR_PACKED;
 231 #pragma pack()
 232 ASSERT_SIZEOF_STRUCT(ata_smart_values, 512);
 233
 234 /* Maxtor, IBM: self-test failure checkpoint byte meaning:
 235  00 - write test
 236  01 - servo basic
 237  02 - servo random
 238  03 - G-list scan
 239  04 - Handling damage
 240  05 - Read scan
 241 */
 242
 243 /* Vendor attribute of SMART Threshold (compare to ata_smart_attribute above) */
 244 #pragma pack(1)
 245 struct ata_smart_threshold_entry {
 246   unsigned char id;
 247   unsigned char threshold;
 248   unsigned char reserved[10];
 249 } ATTR_PACKED;
 250 #pragma pack()
 251 ASSERT_SIZEOF_STRUCT(ata_smart_threshold_entry, 12);
 252
 253 /* Format of Read SMART THreshold Command */
 254 /* Compare to ata_smart_values above */
 255 #pragma pack(1)
 256 struct ata_smart_thresholds_pvt {
 257   unsigned short int revnumber;
 258   struct ata_smart_threshold_entry thres_entries[NUMBER_ATA_SMART_ATTRIBUTES];
 259   unsigned char reserved[149];
 260   unsigned char chksum;
 261 } ATTR_PACKED;
 262 #pragma pack()
 263 ASSERT_SIZEOF_STRUCT(ata_smart_thresholds_pvt, 512);
 264
 265
 266 // Table 42 of T13/1321D Rev 1 spec (Error Data Structure)
 267 #pragma pack(1)
 268 struct ata_smart_errorlog_error_struct {
 269   unsigned char reserved;
 270   unsigned char error_register;
 271   unsigned char sector_count;
 272   unsigned char sector_number;
 273   unsigned char cylinder_low;
 274   unsigned char cylinder_high;
 275   unsigned char drive_head;
 276   unsigned char status;
 277   unsigned char extended_error[19];
 278   unsigned char state;
 279   unsigned short timestamp;
 280 } ATTR_PACKED;
 281 #pragma pack()
 282 ASSERT_SIZEOF_STRUCT(ata_smart_errorlog_error_struct, 30);
 283
 284
 285 // Table 41 of T13/1321D Rev 1 spec (Command Data Structure)
 286 #pragma pack(1)
 287 struct ata_smart_errorlog_command_struct {
 288   unsigned char devicecontrolreg;
 289   unsigned char featuresreg;
 290   unsigned char sector_count;
 291   unsigned char sector_number;
 292   unsigned char cylinder_low;
 293   unsigned char cylinder_high;
 294   unsigned char drive_head;
 295   unsigned char commandreg;
 296   unsigned int timestamp;
 297 } ATTR_PACKED;
 298 #pragma pack()
 299 ASSERT_SIZEOF_STRUCT(ata_smart_errorlog_command_struct, 12);
 300
 301 // Table 40 of T13/1321D Rev 1 spec (Error log data structure)
 302 #pragma pack(1)
 303 struct ata_smart_errorlog_struct {
 304   struct ata_smart_errorlog_command_struct commands[5];
 305   struct ata_smart_errorlog_error_struct error_struct;
 306 } ATTR_PACKED;
 307 #pragma pack()
 308 ASSERT_SIZEOF_STRUCT(ata_smart_errorlog_struct, 90);
 309
 310 // Table 39 of T13/1321D Rev 1 spec (SMART error log sector)
 311 #pragma pack(1)
 312 struct ata_smart_errorlog {
 313   unsigned char revnumber;
 314   unsigned char error_log_pointer;
 315   struct ata_smart_errorlog_struct errorlog_struct[5];
 316   unsigned short int ata_error_count;
 317   unsigned char reserved[57];
 318   unsigned char checksum;
 319 } ATTR_PACKED;
 320 #pragma pack()
 321 ASSERT_SIZEOF_STRUCT(ata_smart_errorlog, 512);
 322
 323
 324 // Extended Comprehensive SMART Error Log data structures
 325 // See Section A.7 of
 326 //   AT Attachment 8 - ATA/ATAPI Command Set (ATA8-ACS)
 327 //   T13/1699-D Revision 6a (Working Draft), September 6, 2008.
 328
 329 // Command data structure
 330 // Table A.9 of T13/1699-D Revision 6a
 331 #pragma pack(1)
 332 struct ata_smart_exterrlog_command
 333 {
 334   unsigned char device_control_register;
 335   unsigned char features_register;
 336   unsigned char features_register_hi;
 337   unsigned char count_register;
 338   unsigned char count_register_hi;
 339   unsigned char lba_low_register;
 340   unsigned char lba_low_register_hi;
 341   unsigned char lba_mid_register;
 342   unsigned char lba_mid_register_hi;
 343   unsigned char lba_high_register;
 344   unsigned char lba_high_register_hi;
 345   unsigned char device_register;
 346   unsigned char command_register;
 347
 348   unsigned char reserved;
 349   unsigned int timestamp;
 350 } ATTR_PACKED;
 351 #pragma pack()
 352 ASSERT_SIZEOF_STRUCT(ata_smart_exterrlog_command, 18);
 353
 354 // Error data structure
 355 // Table A.10 T13/1699-D Revision 6a
 356 #pragma pack(1)
 357 struct ata_smart_exterrlog_error
 358 {
 359   unsigned char device_control_register;
 360   unsigned char error_register;
 361   unsigned char count_register;
 362   unsigned char count_register_hi;
 363   unsigned char lba_low_register;
 364   unsigned char lba_low_register_hi;
 365   unsigned char lba_mid_register;
 366   unsigned char lba_mid_register_hi;
 367   unsigned char lba_high_register;
 368   unsigned char lba_high_register_hi;
 369   unsigned char device_register;
 370   unsigned char status_register;
 371
 372   unsigned char extended_error[19];
 373   unsigned char state;
 374   unsigned short timestamp;
 375 } ATTR_PACKED;
 376 #pragma pack()
 377 ASSERT_SIZEOF_STRUCT(ata_smart_exterrlog_error, 34);
 378
 379 // Error log data structure
 380 // Table A.8 of T13/1699-D Revision 6a
 381 #pragma pack(1)
 382 struct ata_smart_exterrlog_error_log
 383 {
 384   ata_smart_exterrlog_command commands[5];
 385   ata_smart_exterrlog_error error;
 386 } ATTR_PACKED;
 387 #pragma pack()
 388 ASSERT_SIZEOF_STRUCT(ata_smart_exterrlog_error_log, 124);
 389
 390 // Ext. Comprehensive SMART error log
 391 // Table A.7 of T13/1699-D Revision 6a
 392 #pragma pack(1)
 393 struct ata_smart_exterrlog
 394 {
 395   unsigned char version;
 396   unsigned char reserved1;
 397   unsigned short error_log_index;
 398   ata_smart_exterrlog_error_log error_logs[4];
 399   unsigned short device_error_count;
 400   unsigned char reserved2[9];
 401   unsigned char checksum;
 402 } ATTR_PACKED;
 403 #pragma pack()
 404 ASSERT_SIZEOF_STRUCT(ata_smart_exterrlog, 512);
 405
 406
 407 // Table 45 of T13/1321D Rev 1 spec (Self-test log descriptor entry)
 408 #pragma pack(1)
 409 struct ata_smart_selftestlog_struct {
 410   unsigned char selftestnumber; // Sector number register
 411   unsigned char selfteststatus;
 412   unsigned short int timestamp;
 413   unsigned char selftestfailurecheckpoint;
 414   unsigned int lbafirstfailure;
 415   unsigned char vendorspecific[15];
 416 } ATTR_PACKED;
 417 #pragma pack()
 418 ASSERT_SIZEOF_STRUCT(ata_smart_selftestlog_struct, 24);
 419
 420 // Table 44 of T13/1321D Rev 1 spec (Self-test log data structure)
 421 #pragma pack(1)
 422 struct ata_smart_selftestlog {
 423   unsigned short int revnumber;
 424   struct ata_smart_selftestlog_struct selftest_struct[21];
 425   unsigned char vendorspecific[2];
 426   unsigned char mostrecenttest;
 427   unsigned char reserved[2];
 428   unsigned char chksum;
 429 } ATTR_PACKED;
 430 #pragma pack()
 431 ASSERT_SIZEOF_STRUCT(ata_smart_selftestlog, 512);
 432
 433 // Extended SMART Self-test log data structures
 434 // See Section A.8 of
 435 //   AT Attachment 8 - ATA/ATAPI Command Set (ATA8-ACS)
 436 //   T13/1699-D Revision 6a (Working Draft), September 6, 2008.
 437
 438 // Extended Self-test log descriptor entry
 439 // Table A.13 of T13/1699-D Revision 6a
 440 #pragma pack(1)
 441 struct ata_smart_extselftestlog_desc
 442 {
 443   unsigned char self_test_type;
 444   unsigned char self_test_status;
 445   unsigned short timestamp;
 446   unsigned char checkpoint;
 447   unsigned char failing_lba[6];
 448   unsigned char vendorspecific[15];
 449 } ATTR_PACKED;
 450 #pragma pack()
 451 ASSERT_SIZEOF_STRUCT(ata_smart_extselftestlog_desc, 26);
 452
 453 // Extended Self-test log data structure
 454 // Table A.12 of T13/1699-D Revision 6a
 455 #pragma pack(1)
 456 struct ata_smart_extselftestlog
 457 {
 458   unsigned char version;
 459   unsigned char reserved1;
 460   unsigned short log_desc_index;
 461   struct ata_smart_extselftestlog_desc log_descs[19];
 462   unsigned char vendor_specifc[2];
 463   unsigned char reserved2[11];
 464   unsigned char chksum;
 465 } ATTR_PACKED;
 466 #pragma pack()
 467 ASSERT_SIZEOF_STRUCT(ata_smart_extselftestlog, 512);
 468
 469 // SMART LOG DIRECTORY Table 52 of T13/1532D Vol 1 Rev 1a
 470 #pragma pack(1)
 471 struct ata_smart_log_entry {
 472   unsigned char numsectors;
 473   unsigned char reserved;
 474 } ATTR_PACKED;
 475 #pragma pack()
 476 ASSERT_SIZEOF_STRUCT(ata_smart_log_entry, 2);
 477
 478 #pragma pack(1)
 479 struct ata_smart_log_directory {
 480   unsigned short int logversion;
 481   struct ata_smart_log_entry entry[255];
 482 } ATTR_PACKED;
 483 #pragma pack()
 484 ASSERT_SIZEOF_STRUCT(ata_smart_log_directory, 512);
 485
 486 // SMART SELECTIVE SELF-TEST LOG Table 61 of T13/1532D Volume 1
 487 // Revision 3
 488 #pragma pack(1)
 489 struct test_span {
 490   uint64_t start;
 491   uint64_t end;
 492 } ATTR_PACKED;
 493 #pragma pack()
 494 ASSERT_SIZEOF_STRUCT(test_span, 16);
 495
 496 #pragma pack(1)
 497 struct ata_selective_self_test_log {
 498   unsigned short     logversion;
 499   struct test_span   span[5];
 500   unsigned char      reserved1[337-82+1];
 501   unsigned char      vendor_specific1[491-338+1];
 502   uint64_t           currentlba;
 503   unsigned short     currentspan;
 504   unsigned short     flags;
 505   unsigned char      vendor_specific2[507-504+1];
 506   unsigned short     pendingtime;
 507   unsigned char      reserved2;
 508   unsigned char      checksum;
 509 } ATTR_PACKED;
 510 #pragma pack()
 511 ASSERT_SIZEOF_STRUCT(ata_selective_self_test_log, 512);
 512
 513 #define SELECTIVE_FLAG_DOSCAN  (0x0002)
 514 #define SELECTIVE_FLAG_PENDING (0x0008)
 515 #define SELECTIVE_FLAG_ACTIVE  (0x0010)
 516
 517
 518 // SCT (SMART Command Transport) data structures
 519 // See Sections 8.2 and 8.3 of:
 520 //   AT Attachment 8 - ATA/ATAPI Command Set (ATA8-ACS)
 521 //   T13/1699-D Revision 3f (Working Draft), December 11, 2006.
 522
 523 // SCT Status response (read with SMART_READ_LOG page 0xe0)
 524 // Table 182 of T13/BSR INCITS 529 (ACS-4) Revision 04, August 25, 2014
 525 #pragma pack(1)
 526 struct ata_sct_status_response
 527 {
 528   unsigned short format_version;    // 0-1: Status response format version number (2, 3)
 529   unsigned short sct_version;       // 2-3: Vendor specific version number
 530   unsigned short sct_spec;          // 4-5: SCT level supported (1)
 531   unsigned int status_flags;        // 6-9: Status flags (Bit 0: Segment initialized, Bits 1-31: reserved)
 532   unsigned char device_state;       // 10: Device State (0-5)
 533   unsigned char bytes011_013[3];    // 11-13: reserved
 534   unsigned short ext_status_code;   // 14-15: Status of last SCT command (0xffff if executing)
 535   unsigned short action_code;       // 16-17: Action code of last SCT command
 536   unsigned short function_code;     // 18-19: Function code of last SCT command
 537   unsigned char bytes020_039[20];   // 20-39: reserved
 538   uint64_t lba_current;             // 40-47: LBA of SCT command executing in background
 539   unsigned char bytes048_199[152];  // 48-199: reserved
 540   signed char hda_temp;             // 200: Current temperature in Celsius (0x80 = invalid)
 541   signed char min_temp;             // 201: Minimum temperature this power cycle
 542   signed char max_temp;             // 202: Maximum temperature this power cycle
 543   signed char life_min_temp;        // 203: Minimum lifetime temperature
 544   signed char life_max_temp;        // 204: Maximum lifetime temperature
 545   unsigned char byte205;            // 205: reserved (T13/e06152r0-2: Average lifetime temperature)
 546   unsigned int over_limit_count;    // 206-209: # intervals since last reset with temperature > Max Op Limit
 547   unsigned int under_limit_count;   // 210-213: # intervals since last reset with temperature < Min Op Limit
 548   unsigned short smart_status;      // 214-215: LBA(32:8) of SMART RETURN STATUS (0, 0x2cf4, 0xc24f) (ACS-4)
 549   unsigned char bytes216_479[479-216+1]; // 216-479: reserved
 550   unsigned char vendor_specific[32];// 480-511: vendor specific
 551 } ATTR_PACKED;
 552 #pragma pack()
 553 ASSERT_SIZEOF_STRUCT(ata_sct_status_response, 512);
 554
 555 // SCT Error Recovery Control command (send with SMART_WRITE_LOG page 0xe0)
 556 // Table 88 of T13/1699-D Revision 6a
 557 #pragma pack(1)
 558 struct ata_sct_error_recovery_control_command
 559 {
 560   unsigned short action_code;       // 3 = Error Recovery Control
 561   unsigned short function_code;     // 1 = Set, 2 = Return
 562   unsigned short selection_code;    // 1 = Read Timer, 2 = Write Timer
 563   unsigned short time_limit;        // If set: Recovery time limit in 100ms units
 564   unsigned short words004_255[252]; // reserved
 565 } ATTR_PACKED;
 566 #pragma pack()
 567 ASSERT_SIZEOF_STRUCT(ata_sct_error_recovery_control_command, 512);
 568
 569 // SCT Feature Control command (send with SMART_WRITE_LOG page 0xe0)
 570 // Table 72 of T13/1699-D Revision 3f
 571 #pragma pack(1)
 572 struct ata_sct_feature_control_command
 573 {
 574   unsigned short action_code;       // 4 = Feature Control
 575   unsigned short function_code;     // 1 = Set, 2 = Return, 3 = Return options
 576   unsigned short feature_code;      // 3 = Temperature logging interval
 577   unsigned short state;             // Interval
 578   unsigned short option_flags;      // Bit 0: persistent, Bits 1-15: reserved
 579   unsigned short words005_255[251]; // reserved
 580 } ATTR_PACKED;
 581 #pragma pack()
 582 ASSERT_SIZEOF_STRUCT(ata_sct_feature_control_command, 512);
 583
 584 // SCT Data Table command (send with SMART_WRITE_LOG page 0xe0)
 585 // Table 73 of T13/1699-D Revision 3f
 586 #pragma pack(1)
 587 struct ata_sct_data_table_command
 588 {
 589   unsigned short action_code;       // 5 = Data Table
 590   unsigned short function_code;     // 1 = Read Table
 591   unsigned short table_id;          // 2 = Temperature History
 592   unsigned short words003_255[253]; // reserved
 593 } ATTR_PACKED;
 594 #pragma pack()
 595 ASSERT_SIZEOF_STRUCT(ata_sct_data_table_command, 512);
 596
 597 // SCT Temperature History Table (read with SMART_READ_LOG page 0xe1)
 598 // Table 75 of T13/1699-D Revision 3f
 599 #pragma pack(1)
 600 struct ata_sct_temperature_history_table
 601 {
 602   unsigned short format_version;    // 0-1: Data table format version number (2)
 603   unsigned short sampling_period;   // 2-3: Temperature sampling period in minutes
 604   unsigned short interval;          // 4-5: Timer interval between history entries
 605   signed char max_op_limit;         // 6: Maximum recommended continuous operating temperature
 606   signed char over_limit;           // 7: Maximum temperature limit
 607   signed char min_op_limit;         // 8: Minimum recommended continuous operating limit
 608   signed char under_limit;          // 9: Minimum temperature limit
 609   unsigned char bytes010_029[20];   // 10-29: reserved
 610   unsigned short cb_size;           // 30-31: Number of history entries (range 128-478)
 611   unsigned short cb_index;          // 32-33: Index of last updated entry (zero-based)
 612   signed char cb[478];              // 34-(34+cb_size-1): Circular buffer of temperature values
 613 } ATTR_PACKED;
 614 #pragma pack()
 615 ASSERT_SIZEOF_STRUCT(ata_sct_temperature_history_table, 512);
 616
 617 // Possible values for span_args.mode
 618 enum {
 619   SEL_RANGE, // MIN-MAX
 620   SEL_REDO,  // redo this
 621   SEL_NEXT,  // do next range
 622   SEL_CONT   // redo or next depending of last test status
 623 };
 624
 625 // Arguments for selective self-test
 626 struct ata_selective_selftest_args
 627 {
 628   // Arguments for each span
 629   struct span_args
 630   {
 631     uint64_t start;   // First block
 632     uint64_t end;     // Last block
 633     int mode;         // SEL_*, see above
 634
 635     span_args()
 636       : start(0), end(0), mode(SEL_RANGE) { }
 637   };
 638
 639   span_args span[5];  // Range and mode for 5 spans
 640   int num_spans;      // Number of spans
 641   int pending_time;   // One plus time in minutes to wait after powerup before restarting
 642                       // interrupted offline scan after selective self-test.
 643   int scan_after_select; // Run offline scan after selective self-test:
 644                       // 0: don't change,
 645                       // 1: turn off scan after selective self-test,
 646                       // 2: turn on scan after selective self-test.
 647
 648   ata_selective_selftest_args()
 649     : num_spans(0), pending_time(0), scan_after_select(0) { }
 650 };
 651
 652 // Priority for vendor attribute defs
 653 enum ata_vendor_def_prior
 654 {
 655   PRIOR_DEFAULT,
 656   PRIOR_DATABASE,
 657   PRIOR_USER
 658 };
 659
 660 // Raw attribute value print formats
 661 enum ata_attr_raw_format
 662 {
 663   RAWFMT_DEFAULT,
 664   RAWFMT_RAW8,
 665   RAWFMT_RAW16,
 666   RAWFMT_RAW48,
 667   RAWFMT_HEX48,
 668   RAWFMT_RAW56,
 669   RAWFMT_HEX56,
 670   RAWFMT_RAW64,
 671   RAWFMT_HEX64,
 672   RAWFMT_RAW16_OPT_RAW16,
 673   RAWFMT_RAW16_OPT_AVG16,
 674   RAWFMT_RAW24_OPT_RAW8,
 675   RAWFMT_RAW24_DIV_RAW24,
 676   RAWFMT_RAW24_DIV_RAW32,
 677   RAWFMT_SEC2HOUR,
 678   RAWFMT_MIN2HOUR,
 679   RAWFMT_HALFMIN2HOUR,
 680   RAWFMT_MSEC24_HOUR32,
 681   RAWFMT_TEMPMINMAX,
 682   RAWFMT_TEMP10X,
 683 };
 684
 685 // Attribute flags
 686 enum {
 687   ATTRFLAG_INCREASING  = 0x01, // Value not reset (for reallocated/pending counts)
 688   ATTRFLAG_NO_NORMVAL  = 0x02, // Normalized value not valid
 689   ATTRFLAG_NO_WORSTVAL = 0x04, // Worst value not valid
 690   ATTRFLAG_HDD_ONLY    = 0x08, // DEFAULT setting for HDD only
 691   ATTRFLAG_SSD_ONLY    = 0x10, // DEFAULT setting for SSD only
 692 };
 693
 694 // Vendor attribute display defs for all attribute ids
 695 class ata_vendor_attr_defs
 696 {
 697 public:
 698   struct entry
 699   {
 700     std::string name; // Attribute name, empty for default
 701     ata_attr_raw_format raw_format; // Raw value print format
 702     ata_vendor_def_prior priority; // Setting priority
 703     unsigned flags; // ATTRFLAG_*
 704     char byteorder[8+1]; // String [012345rvwz] to define byte order
 705
 706     entry()
 707       : raw_format(RAWFMT_DEFAULT),
 708         priority(PRIOR_DEFAULT),
 709         flags(0)
 710       { byteorder[0] = 0; }
 711   };
 712
 713   entry & operator[](unsigned char id)
 714     { return m_defs[id]; }
 715
 716   const entry & operator[](unsigned char id) const
 717     { return m_defs[id]; }
 718
 719 private:
 720   entry m_defs[256];
 721 };
 722
 723
 724 // Possible values for firmwarebugs
 725 enum firmwarebug_t {
 726   BUG_NONE = 0,
 727   BUG_NOLOGDIR,
 728   BUG_SAMSUNG,
 729   BUG_SAMSUNG2,
 730   BUG_SAMSUNG3,
 731   BUG_XERRORLBA
 732 };
 733
 734 // Set of firmware bugs
 735 class firmwarebug_defs
 736 {
 737 public:
 738   firmwarebug_defs()
 739     : m_bugs(0) { }
 740
 741   bool is_set(firmwarebug_t bug) const
 742     { return !!(m_bugs & (1 << bug)); }
 743
 744   void set(firmwarebug_t bug)
 745     { m_bugs |= (1 << bug); }
 746
 747   void set(firmwarebug_defs bugs)
 748     { m_bugs |= bugs.m_bugs; }
 749
 750 private:
 751   unsigned m_bugs;
 752 };
 753
 754
 755 // Print ATA debug messages?
 756 extern unsigned char ata_debugmode;
 757
 758 // Suppress serial number?
 759 extern bool dont_print_serial_number;
 760
 761 // Get information from drive
 762 int ata_read_identity(ata_device * device, ata_identify_device * buf, bool fix_swapped_id,
 763                       unsigned char * raw_buf = 0);
 764 int ataCheckPowerMode(ata_device * device);
 765
 766 // Issue a no-data ATA command with optional sector count register value
 767 bool ata_nodata_command(ata_device * device, unsigned char command, int sector_count = -1);
 768
 769 // Issue SET FEATURES command with optional sector count register value
 770 bool ata_set_features(ata_device * device, unsigned char features, int sector_count = -1);
 771
 772 /* Read S.M.A.R.T information from drive */
 773 int ataReadSmartValues(ata_device * device,struct ata_smart_values *);
 774 int ataReadSmartThresholds(ata_device * device, struct ata_smart_thresholds_pvt *);
 775 int ataReadErrorLog (ata_device * device, ata_smart_errorlog *data,
 776                      firmwarebug_defs firmwarebugs);
 777 int ataReadSelfTestLog(ata_device * device, ata_smart_selftestlog * data,
 778                        firmwarebug_defs firmwarebugs);
 779 int ataReadSelectiveSelfTestLog(ata_device * device, struct ata_selective_self_test_log *data);
 780 int ataReadLogDirectory(ata_device * device, ata_smart_log_directory *, bool gpl);
 781
 782 // Read GP Log page(s)
 783 bool ataReadLogExt(ata_device * device, unsigned char logaddr,
 784                    unsigned char features, unsigned page,
 785                    void * data, unsigned nsectors);
 786 // Read SMART Log page(s)
 787 bool ataReadSmartLog(ata_device * device, unsigned char logaddr,
 788                      void * data, unsigned nsectors);
 789 // Read SMART Extended Comprehensive Error Log
 790 bool ataReadExtErrorLog(ata_device * device, ata_smart_exterrlog * log,
 791                         unsigned page, unsigned nsectors, firmwarebug_defs firmwarebugs);
 792 // Read SMART Extended Self-test Log
 793 bool ataReadExtSelfTestLog(ata_device * device, ata_smart_extselftestlog * log,
 794                            unsigned nsectors);
 795
 796 // Read SCT information
 797 int ataReadSCTStatus(ata_device * device, ata_sct_status_response * sts);
 798 int ataReadSCTTempHist(ata_device * device, ata_sct_temperature_history_table * tmh,
 799                        ata_sct_status_response * sts);
 800 // Set SCT temperature logging interval
 801 int ataSetSCTTempInterval(ata_device * device, unsigned interval, bool persistent);
 802
 803 // Get/Set SCT Error Recovery Control
 804 int ataGetSCTErrorRecoveryControltime(ata_device * device, unsigned type, unsigned short & time_limit);
 805 int ataSetSCTErrorRecoveryControltime(ata_device * device, unsigned type, unsigned short time_limit);
 806
 807
 808 /* Enable/Disable SMART on device */
 809 int ataEnableSmart (ata_device * device);
 810 int ataDisableSmart (ata_device * device);
 811 int ataEnableAutoSave(ata_device * device);
 812 int ataDisableAutoSave(ata_device * device);
 813
 814 /* Automatic Offline Testing */
 815 int ataEnableAutoOffline (ata_device * device);
 816 int ataDisableAutoOffline (ata_device * device);
 817
 818 /* S.M.A.R.T. test commands */
 819 int ataSmartTest(ata_device * device, int testtype, bool force,
 820                  const ata_selective_selftest_args & args,
 821                  const ata_smart_values * sv, uint64_t num_sectors);
 822
 823 int ataWriteSelectiveSelfTestLog(ata_device * device, ata_selective_selftest_args & args,
 824                                  const ata_smart_values * sv, uint64_t num_sectors,
 825                                  const ata_selective_selftest_args * prev_spans = 0);
 826
 827 // Get World Wide Name (WWN) fields.
 828 // Return NAA field or -1 if WWN is unsupported.
 829 int ata_get_wwn(const ata_identify_device * id, unsigned & oui, uint64_t & unique_id);
 830
 831 // Get nominal media rotation rate.
 832 // Returns: 0 = not reported, 1 = SSD, >1 = HDD rpm, < 0 = -(Unknown value)
 833 int ata_get_rotation_rate(const ata_identify_device * id);
 834
 835 // If SMART supported, this is guaranteed to return 1 if SMART is enabled, else 0.
 836 int ataDoesSmartWork(ata_device * device);
 837
 838 // returns 1 if SMART supported, 0 if not supported or can't tell
 839 int ataSmartSupport(const ata_identify_device * drive);
 840
 841 // Return values:
 842 //  1: Write Cache Reordering enabled
 843 //  2: Write Cache Reordering disabled
 844 // -1: error
 845 int ataGetSetSCTWriteCacheReordering(ata_device * device, bool enable, bool persistent, bool set);
 846
 847 // Return values:
 848 //  1: SMART enabled
 849 //  0: SMART disabled
 850 // -1: can't tell if SMART is enabled -- try issuing ataDoesSmartWork command to see
 851 int ataIsSmartEnabled(const ata_identify_device * drive);
 852
 853 int ataSmartStatus2(ata_device * device);
 854
 855 int isSmartErrorLogCapable(const ata_smart_values * data, const ata_identify_device * identity);
 856
 857 int isSmartTestLogCapable(const ata_smart_values * data, const ata_identify_device * identity);
 858
 859 int isGeneralPurposeLoggingCapable(const ata_identify_device * identity);
 860
 861 int isSupportExecuteOfflineImmediate(const ata_smart_values * data);
 862
 863 int isSupportAutomaticTimer(const ata_smart_values * data);
 864
 865 int isSupportOfflineAbort(const ata_smart_values * data);
 866
 867 int isSupportOfflineSurfaceScan(const ata_smart_values * data);
 868
 869 int isSupportSelfTest(const ata_smart_values * data);
 870
 871 int isSupportConveyanceSelfTest(const ata_smart_values * data);
 872
 873 int isSupportSelectiveSelfTest(const ata_smart_values * data);
 874
 875 inline bool isSCTCapable(const ata_identify_device *drive)
 876   { return !!(drive->words088_255[206-88] & 0x01); } // 0x01 = SCT support
 877
 878 inline bool isSCTErrorRecoveryControlCapable(const ata_identify_device *drive)
 879   { return ((drive->words088_255[206-88] & 0x09) == 0x09); } // 0x08 = SCT Error Recovery Control support
 880
 881 inline bool isSCTFeatureControlCapable(const ata_identify_device *drive)
 882   { return ((drive->words088_255[206-88] & 0x11) == 0x11); } // 0x10 = SCT Feature Control support
 883
 884 inline bool isSCTDataTableCapable(const ata_identify_device *drive)
 885   { return ((drive->words088_255[206-88] & 0x21) == 0x21); } // 0x20 = SCT Data Table support
 886
 887 int TestTime(const ata_smart_values * data, int testtype);
 888
 889 // Attribute state
 890 enum ata_attr_state
 891 {
 892   ATTRSTATE_NON_EXISTING,   // No such Attribute
 893   ATTRSTATE_NO_NORMVAL,     // Normalized value not valid
 894   ATTRSTATE_NO_THRESHOLD,   // Unknown or no threshold
 895   ATTRSTATE_OK,             // Never failed
 896   ATTRSTATE_FAILED_PAST,    // Failed in the past
 897   ATTRSTATE_FAILED_NOW      // Failed now
 898 };
 899
 900 // Get attribute state
 901 ata_attr_state ata_get_attr_state(const ata_smart_attribute & attr,
 902                                   int attridx,
 903                                   const ata_smart_threshold_entry * thresholds,
 904                                   const ata_vendor_attr_defs & defs,
 905                                   unsigned char * threshval = 0);
 906
 907 // Get attribute raw value.
 908 uint64_t ata_get_attr_raw_value(const ata_smart_attribute & attr,
 909                                 const ata_vendor_attr_defs & defs);
 910
 911 // Format attribute raw value.
 912 std::string ata_format_attr_raw_value(const ata_smart_attribute & attr,
 913                                       const ata_vendor_attr_defs & defs);
 914
 915 // Get attribute name
 916 std::string ata_get_smart_attr_name(unsigned char id,
 917                                     const ata_vendor_attr_defs & defs,
 918                                     int rpm = 0);
 919
 920 // External handler function, for when a checksum is not correct.  Can
 921 // simply return if no action is desired, or can print error messages
 922 // as needed, or exit.  Is passed a string with the name of the Data
 923 // Structure with the incorrect checksum.
 924 void checksumwarning(const char *string);
 925
 926 // Find attribute index for attribute id, -1 if not found.
 927 int ata_find_attr_index(unsigned char id, const ata_smart_values & smartval);
 928
 929 // Return Temperature Attribute raw value selected according to possible
 930 // non-default interpretations. If the Attribute does not exist, return 0
 931 unsigned char ata_return_temperature_value(const ata_smart_values * data, const ata_vendor_attr_defs & defs);
 932
 933
 934 #define MAX_ATTRIBUTE_NUM 256
 935
 936 // Parse vendor attribute display def (-v option).
 937 // Return false on error.
 938 bool parse_attribute_def(const char * opt, ata_vendor_attr_defs & defs,
 939                          ata_vendor_def_prior priority);
 940
 941 // Get ID and increase flag of current pending or offline
 942 // uncorrectable attribute.
 943 unsigned char get_unc_attr_id(bool offline, const ata_vendor_attr_defs & defs,
 944                               bool & increase);
 945
 946 // Return a multiline string containing a list of valid arguments for
 947 // parse_attribute_def().
 948 std::string create_vendor_attribute_arg_list();
 949
 950 // Parse firmwarebug def (-F option).
 951 // Return false on error.
 952 bool parse_firmwarebug_def(const char * opt, firmwarebug_defs & firmwarebugs);
 953
 954 // Return a string of valid argument words for parse_firmwarebug_def()
 955 const char * get_valid_firmwarebug_args();
 956
 957
 958 // These are two of the functions that are defined in os_*.c and need
 959 // to be ported to get smartmontools onto another OS.
 960 // Moved to C++ interface
 961 //int ata_command_interface(int device, smart_command_set command, int select, char *data);
 962 //int escalade_command_interface(int fd, int escalade_port, int escalade_type, smart_command_set command, int select, char *data);
 963 //int marvell_command_interface(int device, smart_command_set command, int select, char *data);
 964 //int highpoint_command_interface(int device, smart_command_set command, int select, char *data);
 965 //int areca_command_interface(int fd, int disknum, smart_command_set command, int select, char *data);
 966
 967
 968 // This function is exported to give low-level capability
 969 int smartcommandhandler(ata_device * device, smart_command_set command, int select, char *data);
 970
 971 // Print one self-test log entry.
 972 // Returns:
 973 // -1: failed self-test
 974 //  1: extended self-test completed without error
 975 //  0: otherwise
 976 int ataPrintSmartSelfTestEntry(unsigned testnum, unsigned char test_type,
 977                                unsigned char test_status,
 978                                unsigned short timestamp,
 979                                uint64_t failing_lba,
 980                                bool print_error_only, bool & print_header);
 981
 982 // Print Smart self-test log, used by smartctl and smartd.
 983 int ataPrintSmartSelfTestlog(const ata_smart_selftestlog * data, bool allentries,
 984                              firmwarebug_defs firmwarebugs);
 985
 986 // Get capacity and sector sizes from IDENTIFY data
 987 struct ata_size_info
 988 {
 989   uint64_t sectors;
 990   uint64_t capacity;
 991   unsigned log_sector_size;
 992   unsigned phy_sector_size;
 993   unsigned log_sector_offset;
 994 };
 995
 996 void ata_get_size_info(const ata_identify_device * id, ata_size_info & sizes);
 997
 998 // Convenience function for formatting strings from ata_identify_device.
 999 void ata_format_id_string(char * out, const unsigned char * in, int n);
1000
1001 // Utility routines.
1002 unsigned char checksum(const void * data);
1003
1004 void swap2(char *location);
1005 void swap4(char *location);
1006 void swap8(char *location);
1007 // Typesafe variants using overloading
1008 inline void swapx(unsigned short * p)
1009   { swap2((char*)p); }
1010 inline void swapx(unsigned int * p)
1011   { swap4((char*)p); }
1012 inline void swapx(uint64_t * p)
1013   { swap8((char*)p); }
1014
1015 // Return pseudo-device to parse "smartctl -r ataioctl,2 ..." output
1016 // and simulate an ATA device with same behaviour
1017 ata_device * get_parsed_ata_device(smart_interface * intf, const char * dev_name);
1018
1019 #endif /* ATACMDS_H_ */