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