#define ADV_PIO_MODES 64 /* advanced PIO modes supported */
/* multiword DMA xfer cycle time: */
#define DMA_TIME_MIN 65 /* - minimum */
-#define DMA_TIME_NORM 66 /* - manufacturer's recommended */
+#define DMA_TIME_NORM 66 /* - manufacturer's recommended */
/* minimum PIO xfer cycle time: */
#define PIO_NO_FLOW 67 /* - without flow control */
#define PIO_FLOW 68 /* - with IORDY flow control */
#define ENH_ERASE_TIME 90 /* - enhanced */
#define ADV_PWR 91 /* current advanced power management level
in low byte, 0x40 in high byte. */
-#define PSWD_CODE 92 /* master password revision code */
+#define PSWD_CODE 92 /* master password revision code */
#define HWRST_RSLT 93 /* hardware reset result */
#define ACOUSTIC 94 /* acoustic mgmt values ( >= ATA-6) */
#define LBA_LSB 100 /* LBA: maximum. Currently only 48 */
#define CDROM 0x0005
-#if ENABLE_FEATURE_HDPARM_GET_IDENTITY
-static const char *const pkt_str[] = {
- "Direct-access device", /* word 0, bits 12-8 = 00 */
- "Sequential-access device", /* word 0, bits 12-8 = 01 */
- "Printer", /* word 0, bits 12-8 = 02 */
- "Processor", /* word 0, bits 12-8 = 03 */
- "Write-once device", /* word 0, bits 12-8 = 04 */
- "CD-ROM", /* word 0, bits 12-8 = 05 */
- "Scanner", /* word 0, bits 12-8 = 06 */
- "Optical memory", /* word 0, bits 12-8 = 07 */
- "Medium changer", /* word 0, bits 12-8 = 08 */
- "Communications device", /* word 0, bits 12-8 = 09 */
- "ACS-IT8 device", /* word 0, bits 12-8 = 0a */
- "ACS-IT8 device", /* word 0, bits 12-8 = 0b */
- "Array controller", /* word 0, bits 12-8 = 0c */
- "Enclosure services", /* word 0, bits 12-8 = 0d */
- "Reduced block command device", /* word 0, bits 12-8 = 0e */
- "Optical card reader/writer", /* word 0, bits 12-8 = 0f */
- "", /* word 0, bits 12-8 = 10 */
- "", /* word 0, bits 12-8 = 11 */
- "", /* word 0, bits 12-8 = 12 */
- "", /* word 0, bits 12-8 = 13 */
- "", /* word 0, bits 12-8 = 14 */
- "", /* word 0, bits 12-8 = 15 */
- "", /* word 0, bits 12-8 = 16 */
- "", /* word 0, bits 12-8 = 17 */
- "", /* word 0, bits 12-8 = 18 */
- "", /* word 0, bits 12-8 = 19 */
- "", /* word 0, bits 12-8 = 1a */
- "", /* word 0, bits 12-8 = 1b */
- "", /* word 0, bits 12-8 = 1c */
- "", /* word 0, bits 12-8 = 1d */
- "", /* word 0, bits 12-8 = 1e */
- "Unknown", /* word 0, bits 12-8 = 1f */
-};
-
-static const char *const ata1_cfg_str[] = { /* word 0 in ATA-1 mode */
- "Reserved", /* bit 0 */
- "hard sectored", /* bit 1 */
- "soft sectored", /* bit 2 */
- "not MFM encoded ", /* bit 3 */
- "head switch time > 15us", /* bit 4 */
- "spindle motor control option", /* bit 5 */
- "fixed drive", /* bit 6 */
- "removable drive", /* bit 7 */
- "disk xfer rate <= 5Mbs", /* bit 8 */
- "disk xfer rate > 5Mbs, <= 10Mbs", /* bit 9 */
- "disk xfer rate > 5Mbs", /* bit 10 */
- "rotational speed tol.", /* bit 11 */
- "data strobe offset option", /* bit 12 */
- "track offset option", /* bit 13 */
- "format speed tolerance gap reqd", /* bit 14 */
- "ATAPI" /* bit 14 */
-};
-#endif
-
/* word 1: number of logical cylinders */
#define LCYLS_MAX 0x3fff /* maximum allowable value */
/* word 81: minor version number */
#define MINOR_MAX 0x22
-#if ENABLE_FEATURE_HDPARM_GET_IDENTITY
-static const char *const minor_str[MINOR_MAX + 2] = {
- /* word 81 value: */
- "Unspecified", /* 0x0000 */
- "ATA-1 X3T9.2 781D prior to rev.4", /* 0x0001 */
- "ATA-1 published, ANSI X3.221-1994", /* 0x0002 */
- "ATA-1 X3T9.2 781D rev.4", /* 0x0003 */
- "ATA-2 published, ANSI X3.279-1996", /* 0x0004 */
- "ATA-2 X3T10 948D prior to rev.2k", /* 0x0005 */
- "ATA-3 X3T10 2008D rev.1", /* 0x0006 */
- "ATA-2 X3T10 948D rev.2k", /* 0x0007 */
- "ATA-3 X3T10 2008D rev.0", /* 0x0008 */
- "ATA-2 X3T10 948D rev.3", /* 0x0009 */
- "ATA-3 published, ANSI X3.298-199x", /* 0x000a */
- "ATA-3 X3T10 2008D rev.6", /* 0x000b */
- "ATA-3 X3T13 2008D rev.7 and 7a", /* 0x000c */
- "ATA/ATAPI-4 X3T13 1153D rev.6", /* 0x000d */
- "ATA/ATAPI-4 T13 1153D rev.13", /* 0x000e */
- "ATA/ATAPI-4 X3T13 1153D rev.7", /* 0x000f */
- "ATA/ATAPI-4 T13 1153D rev.18", /* 0x0010 */
- "ATA/ATAPI-4 T13 1153D rev.15", /* 0x0011 */
- "ATA/ATAPI-4 published, ANSI INCITS 317-1998", /* 0x0012 */
- "ATA/ATAPI-5 T13 1321D rev.3", /* 0x0013 */
- "ATA/ATAPI-4 T13 1153D rev.14", /* 0x0014 */
- "ATA/ATAPI-5 T13 1321D rev.1", /* 0x0015 */
- "ATA/ATAPI-5 published, ANSI INCITS 340-2000", /* 0x0016 */
- "ATA/ATAPI-4 T13 1153D rev.17", /* 0x0017 */
- "ATA/ATAPI-6 T13 1410D rev.0", /* 0x0018 */
- "ATA/ATAPI-6 T13 1410D rev.3a", /* 0x0019 */
- "ATA/ATAPI-7 T13 1532D rev.1", /* 0x001a */
- "ATA/ATAPI-6 T13 1410D rev.2", /* 0x001b */
- "ATA/ATAPI-6 T13 1410D rev.1", /* 0x001c */
- "ATA/ATAPI-7 published, ANSI INCITS 397-2005", /* 0x001d */
- "ATA/ATAPI-7 T13 1532D rev.0", /* 0x001e */
- "Reserved" /* 0x001f */
- "Reserved" /* 0x0020 */
- "ATA/ATAPI-7 T13 1532D rev.4a", /* 0x0021 */
- "ATA/ATAPI-6 published, ANSI INCITS 361-2002", /* 0x0022 */
- "Reserved" /* 0x0023-0xfffe */
-};
-#endif
-static const char actual_ver[MINOR_MAX + 2] ALIGN1 = {
- /* word 81 value: */
- 0, /* 0x0000 WARNING: actual_ver[] array */
- 1, /* 0x0001 WARNING: corresponds */
- 1, /* 0x0002 WARNING: *exactly* */
- 1, /* 0x0003 WARNING: to the ATA/ */
- 2, /* 0x0004 WARNING: ATAPI version */
- 2, /* 0x0005 WARNING: listed in */
- 3, /* 0x0006 WARNING: the */
- 2, /* 0x0007 WARNING: minor_str */
- 3, /* 0x0008 WARNING: array */
- 2, /* 0x0009 WARNING: above. */
- 3, /* 0x000a WARNING: */
- 3, /* 0x000b WARNING: If you change */
- 3, /* 0x000c WARNING: that one, */
- 4, /* 0x000d WARNING: change this one */
- 4, /* 0x000e WARNING: too!!! */
- 4, /* 0x000f */
- 4, /* 0x0010 */
- 4, /* 0x0011 */
- 4, /* 0x0012 */
- 5, /* 0x0013 */
- 4, /* 0x0014 */
- 5, /* 0x0015 */
- 5, /* 0x0016 */
- 4, /* 0x0017 */
- 6, /* 0x0018 */
- 6, /* 0x0019 */
- 7, /* 0x001a */
- 6, /* 0x001b */
- 6, /* 0x001c */
- 7, /* 0x001d */
- 7, /* 0x001e */
- 0, /* 0x001f */
- 0, /* 0x0020 */
- 7, /* 0x0021 */
- 6, /* 0x0022 */
- 0 /* 0x0023-0xfffe */
-};
-
/* words 82-84: cmds/feats supported */
#define CMDS_W82 0x77ff /* word 82: defined command locations*/
#define CMDS_W83 0x3fff /* word 83: defined command locations*/
#define SUPPORT_48_BIT 0x0400
#define NUM_CMD_FEAT_STR 48
-#if ENABLE_FEATURE_HDPARM_GET_IDENTITY
-static const char *const cmd_feat_str[] = {
- "", /* word 82 bit 15: obsolete */
- "NOP cmd", /* word 82 bit 14 */
- "READ BUFFER cmd", /* word 82 bit 13 */
- "WRITE BUFFER cmd", /* word 82 bit 12 */
- "", /* word 82 bit 11: obsolete */
- "Host Protected Area feature set", /* word 82 bit 10 */
- "DEVICE RESET cmd", /* word 82 bit 9 */
- "SERVICE interrupt", /* word 82 bit 8 */
- "Release interrupt", /* word 82 bit 7 */
- "Look-ahead", /* word 82 bit 6 */
- "Write cache", /* word 82 bit 5 */
- "PACKET command feature set", /* word 82 bit 4 */
- "Power Management feature set", /* word 82 bit 3 */
- "Removable Media feature set", /* word 82 bit 2 */
- "Security Mode feature set", /* word 82 bit 1 */
- "SMART feature set", /* word 82 bit 0 */
- /* -------------- */
- "", /* word 83 bit 15: !valid bit */
- "", /* word 83 bit 14: valid bit */
- "FLUSH CACHE EXT cmd", /* word 83 bit 13 */
- "Mandatory FLUSH CACHE cmd ", /* word 83 bit 12 */
- "Device Configuration Overlay feature set ",
- "48-bit Address feature set ", /* word 83 bit 10 */
- "",
- "SET MAX security extension", /* word 83 bit 8 */
- "Address Offset Reserved Area Boot", /* word 83 bit 7 */
- "SET FEATURES subcommand required to spinup after power up",
- "Power-Up In Standby feature set", /* word 83 bit 5 */
- "Removable Media Status Notification feature set",
- "Adv. Power Management feature set", /* word 83 bit 3 */
- "CFA feature set", /* word 83 bit 2 */
- "READ/WRITE DMA QUEUED", /* word 83 bit 1 */
- "DOWNLOAD MICROCODE cmd", /* word 83 bit 0 */
- /* -------------- */
- "", /* word 84 bit 15: !valid bit */
- "", /* word 84 bit 14: valid bit */
- "", /* word 84 bit 13: reserved */
- "", /* word 84 bit 12: reserved */
- "", /* word 84 bit 11: reserved */
- "", /* word 84 bit 10: reserved */
- "", /* word 84 bit 9: reserved */
- "", /* word 84 bit 8: reserved */
- "", /* word 84 bit 7: reserved */
- "", /* word 84 bit 6: reserved */
- "General Purpose Logging feature set", /* word 84 bit 5 */
- "", /* word 84 bit 4: reserved */
- "Media Card Pass Through Command feature set ",
- "Media serial number ", /* word 84 bit 2 */
- "SMART self-test ", /* word 84 bit 1 */
- "SMART error logging " /* word 84 bit 0 */
-};
-#endif
-
-
/* words 85-87: cmds/feats enabled */
/* use cmd_feat_str[] to display what commands and features have
* been enabled with words 85-87
#define SECU_ENABLED 0x0002
#define SECU_LEVEL 0x0010
#define NUM_SECU_STR 6
-#if ENABLE_FEATURE_HDPARM_GET_IDENTITY
-static const char *const secu_str[] = {
- "supported", /* word 128, bit 0 */
- "enabled", /* word 128, bit 1 */
- "locked", /* word 128, bit 2 */
- "frozen", /* word 128, bit 3 */
- "expired: security count", /* word 128, bit 4 */
- "supported: enhanced erase" /* word 128, bit 5 */
-};
-#endif
/* word 160: CFA power mode */
#define VALID_W160 0x8000 /* 1=word valid */
#define SIG 0x00ff /* signature location */
#define SIG_VAL 0x00a5 /* signature value */
-#define TIMING_MB 64
#define TIMING_BUF_MB 1
#define TIMING_BUF_BYTES (TIMING_BUF_MB * 1024 * 1024)
-#define BUFCACHE_FACTOR 2
#undef DO_FLUSHCACHE /* under construction: force cache flush on -W0 */
smallint set_readonly, get_readonly;
smallint set_unmask, get_unmask;
smallint set_mult, get_mult;
- smallint set_dma_q, get_dma_q;
+#ifdef HDIO_GET_QDMA
+ smallint get_dma_q;
+#ifdef HDIO_SET_QDMA
+ smallint set_dma_q;
+#endif
+#endif
smallint set_nowerr, get_nowerr;
smallint set_keep, get_keep;
smallint set_io32bit, get_io32bit;
unsigned long readonly;
unsigned long unmask;
unsigned long mult;
+#ifdef HDIO_SET_QDMA
unsigned long dma_q;
+#endif
unsigned long nowerr;
unsigned long keep;
unsigned long io32bit;
smallint set_apmmode, get_apmmode;
int xfermode_requested;
unsigned long dkeep;
- unsigned long standby_requested;
+ unsigned long standby_requested; /* 0..255 */
unsigned long lookahead;
unsigned long prefetch;
unsigned long defects;
unsigned long hwif_ctrl;
unsigned long hwif_irq;
#endif
+#ifdef DO_FLUSHCACHE
+ unsigned char flushcache[4] = { WIN_FLUSHCACHE, 0, 0, 0 };
+#endif
};
#define G (*(struct globals*)&bb_common_bufsiz1)
struct BUG_G_too_big {
return err_dma;
}
-// Parse 512 byte disk identification block and print much crap.
+static const char pkt_str[] ALIGN1 =
+ "Direct-access device" "\0" /* word 0, bits 12-8 = 00 */
+ "Sequential-access device" "\0" /* word 0, bits 12-8 = 01 */
+ "Printer" "\0" /* word 0, bits 12-8 = 02 */
+ "Processor" "\0" /* word 0, bits 12-8 = 03 */
+ "Write-once device" "\0" /* word 0, bits 12-8 = 04 */
+ "CD-ROM" "\0" /* word 0, bits 12-8 = 05 */
+ "Scanner" "\0" /* word 0, bits 12-8 = 06 */
+ "Optical memory" "\0" /* word 0, bits 12-8 = 07 */
+ "Medium changer" "\0" /* word 0, bits 12-8 = 08 */
+ "Communications device" "\0" /* word 0, bits 12-8 = 09 */
+ "ACS-IT8 device" "\0" /* word 0, bits 12-8 = 0a */
+ "ACS-IT8 device" "\0" /* word 0, bits 12-8 = 0b */
+ "Array controller" "\0" /* word 0, bits 12-8 = 0c */
+ "Enclosure services" "\0" /* word 0, bits 12-8 = 0d */
+ "Reduced block command device" "\0" /* word 0, bits 12-8 = 0e */
+ "Optical card reader/writer" "\0" /* word 0, bits 12-8 = 0f */
+;
+
+static const char ata1_cfg_str[] ALIGN1 = /* word 0 in ATA-1 mode */
+ "reserved" "\0" /* bit 0 */
+ "hard sectored" "\0" /* bit 1 */
+ "soft sectored" "\0" /* bit 2 */
+ "not MFM encoded " "\0" /* bit 3 */
+ "head switch time > 15us" "\0" /* bit 4 */
+ "spindle motor control option" "\0" /* bit 5 */
+ "fixed drive" "\0" /* bit 6 */
+ "removable drive" "\0" /* bit 7 */
+ "disk xfer rate <= 5Mbs" "\0" /* bit 8 */
+ "disk xfer rate > 5Mbs, <= 10Mbs" "\0" /* bit 9 */
+ "disk xfer rate > 5Mbs" "\0" /* bit 10 */
+ "rotational speed tol." "\0" /* bit 11 */
+ "data strobe offset option" "\0" /* bit 12 */
+ "track offset option" "\0" /* bit 13 */
+ "format speed tolerance gap reqd" "\0" /* bit 14 */
+ "ATAPI" /* bit 14 */
+;
+
+static const char minor_str[] ALIGN1 =
+ /* word 81 value: */
+ "Unspecified" "\0" /* 0x0000 */
+ "ATA-1 X3T9.2 781D prior to rev.4" "\0" /* 0x0001 */
+ "ATA-1 published, ANSI X3.221-1994" "\0" /* 0x0002 */
+ "ATA-1 X3T9.2 781D rev.4" "\0" /* 0x0003 */
+ "ATA-2 published, ANSI X3.279-1996" "\0" /* 0x0004 */
+ "ATA-2 X3T10 948D prior to rev.2k" "\0" /* 0x0005 */
+ "ATA-3 X3T10 2008D rev.1" "\0" /* 0x0006 */
+ "ATA-2 X3T10 948D rev.2k" "\0" /* 0x0007 */
+ "ATA-3 X3T10 2008D rev.0" "\0" /* 0x0008 */
+ "ATA-2 X3T10 948D rev.3" "\0" /* 0x0009 */
+ "ATA-3 published, ANSI X3.298-199x" "\0" /* 0x000a */
+ "ATA-3 X3T10 2008D rev.6" "\0" /* 0x000b */
+ "ATA-3 X3T13 2008D rev.7 and 7a" "\0" /* 0x000c */
+ "ATA/ATAPI-4 X3T13 1153D rev.6" "\0" /* 0x000d */
+ "ATA/ATAPI-4 T13 1153D rev.13" "\0" /* 0x000e */
+ "ATA/ATAPI-4 X3T13 1153D rev.7" "\0" /* 0x000f */
+ "ATA/ATAPI-4 T13 1153D rev.18" "\0" /* 0x0010 */
+ "ATA/ATAPI-4 T13 1153D rev.15" "\0" /* 0x0011 */
+ "ATA/ATAPI-4 published, ANSI INCITS 317-1998" "\0" /* 0x0012 */
+ "ATA/ATAPI-5 T13 1321D rev.3" "\0" /* 0x0013 */
+ "ATA/ATAPI-4 T13 1153D rev.14" "\0" /* 0x0014 */
+ "ATA/ATAPI-5 T13 1321D rev.1" "\0" /* 0x0015 */
+ "ATA/ATAPI-5 published, ANSI INCITS 340-2000" "\0" /* 0x0016 */
+ "ATA/ATAPI-4 T13 1153D rev.17" "\0" /* 0x0017 */
+ "ATA/ATAPI-6 T13 1410D rev.0" "\0" /* 0x0018 */
+ "ATA/ATAPI-6 T13 1410D rev.3a" "\0" /* 0x0019 */
+ "ATA/ATAPI-7 T13 1532D rev.1" "\0" /* 0x001a */
+ "ATA/ATAPI-6 T13 1410D rev.2" "\0" /* 0x001b */
+ "ATA/ATAPI-6 T13 1410D rev.1" "\0" /* 0x001c */
+ "ATA/ATAPI-7 published, ANSI INCITS 397-2005" "\0" /* 0x001d */
+ "ATA/ATAPI-7 T13 1532D rev.0" "\0" /* 0x001e */
+ "reserved" "\0" /* 0x001f */
+ "reserved" "\0" /* 0x0020 */
+ "ATA/ATAPI-7 T13 1532D rev.4a" "\0" /* 0x0021 */
+ "ATA/ATAPI-6 published, ANSI INCITS 361-2002" "\0" /* 0x0022 */
+ "reserved" /* 0x0023-0xfffe */
+;
+static const char actual_ver[MINOR_MAX + 2] ALIGN1 = {
+ /* word 81 value: */
+ 0, /* 0x0000 WARNING: actual_ver[] array */
+ 1, /* 0x0001 WARNING: corresponds */
+ 1, /* 0x0002 WARNING: *exactly* */
+ 1, /* 0x0003 WARNING: to the ATA/ */
+ 2, /* 0x0004 WARNING: ATAPI version */
+ 2, /* 0x0005 WARNING: listed in */
+ 3, /* 0x0006 WARNING: the */
+ 2, /* 0x0007 WARNING: minor_str */
+ 3, /* 0x0008 WARNING: array */
+ 2, /* 0x0009 WARNING: above. */
+ 3, /* 0x000a WARNING: */
+ 3, /* 0x000b WARNING: If you change */
+ 3, /* 0x000c WARNING: that one, */
+ 4, /* 0x000d WARNING: change this one */
+ 4, /* 0x000e WARNING: too!!! */
+ 4, /* 0x000f */
+ 4, /* 0x0010 */
+ 4, /* 0x0011 */
+ 4, /* 0x0012 */
+ 5, /* 0x0013 */
+ 4, /* 0x0014 */
+ 5, /* 0x0015 */
+ 5, /* 0x0016 */
+ 4, /* 0x0017 */
+ 6, /* 0x0018 */
+ 6, /* 0x0019 */
+ 7, /* 0x001a */
+ 6, /* 0x001b */
+ 6, /* 0x001c */
+ 7, /* 0x001d */
+ 7, /* 0x001e */
+ 0, /* 0x001f */
+ 0, /* 0x0020 */
+ 7, /* 0x0021 */
+ 6, /* 0x0022 */
+ 0 /* 0x0023-0xfffe */
+};
-static void identify(uint16_t *val) ATTRIBUTE_NORETURN;
+static const char cmd_feat_str[] ALIGN1 =
+ "" "\0" /* word 82 bit 15: obsolete */
+ "NOP cmd" "\0" /* word 82 bit 14 */
+ "READ BUFFER cmd" "\0" /* word 82 bit 13 */
+ "WRITE BUFFER cmd" "\0" /* word 82 bit 12 */
+ "" "\0" /* word 82 bit 11: obsolete */
+ "Host Protected Area feature set" "\0" /* word 82 bit 10 */
+ "DEVICE RESET cmd" "\0" /* word 82 bit 9 */
+ "SERVICE interrupt" "\0" /* word 82 bit 8 */
+ "Release interrupt" "\0" /* word 82 bit 7 */
+ "Look-ahead" "\0" /* word 82 bit 6 */
+ "Write cache" "\0" /* word 82 bit 5 */
+ "PACKET command feature set" "\0" /* word 82 bit 4 */
+ "Power Management feature set" "\0" /* word 82 bit 3 */
+ "Removable Media feature set" "\0" /* word 82 bit 2 */
+ "Security Mode feature set" "\0" /* word 82 bit 1 */
+ "SMART feature set" "\0" /* word 82 bit 0 */
+ /* -------------- */
+ "" "\0" /* word 83 bit 15: !valid bit */
+ "" "\0" /* word 83 bit 14: valid bit */
+ "FLUSH CACHE EXT cmd" "\0" /* word 83 bit 13 */
+ "Mandatory FLUSH CACHE cmd " "\0" /* word 83 bit 12 */
+ "Device Configuration Overlay feature set " "\0"
+ "48-bit Address feature set " "\0" /* word 83 bit 10 */
+ "" "\0"
+ "SET MAX security extension" "\0" /* word 83 bit 8 */
+ "Address Offset Reserved Area Boot" "\0" /* word 83 bit 7 */
+ "SET FEATURES subcommand required to spinup after power up" "\0"
+ "Power-Up In Standby feature set" "\0" /* word 83 bit 5 */
+ "Removable Media Status Notification feature set" "\0"
+ "Adv. Power Management feature set" "\0" /* word 83 bit 3 */
+ "CFA feature set" "\0" /* word 83 bit 2 */
+ "READ/WRITE DMA QUEUED" "\0" /* word 83 bit 1 */
+ "DOWNLOAD MICROCODE cmd" "\0" /* word 83 bit 0 */
+ /* -------------- */
+ "" "\0" /* word 84 bit 15: !valid bit */
+ "" "\0" /* word 84 bit 14: valid bit */
+ "" "\0" /* word 84 bit 13: reserved */
+ "" "\0" /* word 84 bit 12: reserved */
+ "" "\0" /* word 84 bit 11: reserved */
+ "" "\0" /* word 84 bit 10: reserved */
+ "" "\0" /* word 84 bit 9: reserved */
+ "" "\0" /* word 84 bit 8: reserved */
+ "" "\0" /* word 84 bit 7: reserved */
+ "" "\0" /* word 84 bit 6: reserved */
+ "General Purpose Logging feature set" "\0" /* word 84 bit 5 */
+ "" "\0" /* word 84 bit 4: reserved */
+ "Media Card Pass Through Command feature set " "\0"
+ "Media serial number " "\0" /* word 84 bit 2 */
+ "SMART self-test " "\0" /* word 84 bit 1 */
+ "SMART error logging " /* word 84 bit 0 */
+;
+
+static const char secu_str[] ALIGN1 =
+ "supported" "\0" /* word 128, bit 0 */
+ "enabled" "\0" /* word 128, bit 1 */
+ "locked" "\0" /* word 128, bit 2 */
+ "frozen" "\0" /* word 128, bit 3 */
+ "expired: security count" "\0" /* word 128, bit 4 */
+ "supported: enhanced erase" /* word 128, bit 5 */
+;
+
+// Parse 512 byte disk identification block and print much crap.
+static void identify(uint16_t *val) NORETURN;
static void identify(uint16_t *val)
{
uint16_t ii, jj, kk;
} else if (!(val[GEN_CONFIG] & NOT_ATAPI)) {
dev = ATAPI_DEV;
eqpt = (val[GEN_CONFIG] & EQPT_TYPE) >> SHIFT_EQPT;
- printf("ATAPI %s, with ", pkt_str[eqpt]);
+ printf("ATAPI %s, with ", eqpt <= 0xf ? nth_string(pkt_str, eqpt) : "unknown");
like_std = 3;
} else
- /*"Unknown device type:\n\tbits 15&14 of general configuration word 0 both set to 1.\n"*/
+ /* "Unknown device type:\n\tbits 15&14 of general configuration word 0 both set to 1.\n" */
bb_error_msg_and_die("unknown device type");
printf("%sremovable media\n", !(val[GEN_CONFIG] & MEDIA_REMOVABLE) ? "non-" : "");
if (val[MINOR] && (val[MINOR] <= MINOR_MAX)) {
if (like_std < 3) like_std = 3;
std = actual_ver[val[MINOR]];
- if (std) printf("\n\tUsed: %s ", minor_str[val[MINOR]]);
+ if (std) printf("\n\tUsed: %s ", nth_string(minor_str, val[MINOR]));
}
/* looks like when they up-issue the std, they obsolete one;
jj >>= 1;
}
}
- printf("%s\n", kk ? "" : "\n\tLikely used CD-ROM ATAPI-1");
+ puts(kk ? "" : "\n\tLikely used CD-ROM ATAPI-1");
/* the cdrom stuff is more like ATA-2 than anything else, so: */
like_std = 2;
}
jj = val[GEN_CONFIG] >> 1;
for (ii = 1; ii < 15; ii++) {
if (jj & 0x0001)
- printf("\t%s\n", ata1_cfg_str[ii]);
+ printf("\t%s\n", nth_string(ata1_cfg_str, ii));
jj >>=1;
}
}
else if ((val[GEN_CONFIG] & DRQ_RESPONSE_TIME) == DRQ_50US_VAL)
strng ="50us";
else
- strng = "Unknown";
+ strng = "unknown";
printf("\tDRQ response: %s\n\tPacket size: ", strng); /* Data Request (DRQ) */
if ((val[GEN_CONFIG] & PKT_SIZE_SUPPORTED) == PKT_SIZE_12_VAL)
else if ((val[GEN_CONFIG] & PKT_SIZE_SUPPORTED) == PKT_SIZE_16_VAL)
strng = "16 bytes";
else
- strng = "Unknown";
+ strng = "unknown";
puts(strng);
} else {
/* addressing...CHS? See section 6.2 of ATA specs 4 or 5 */
printf("pio%d ", ii);
bb_putchar('\n');
} else
- printf("unknown\n");
+ puts("unknown");
if (val[WHATS_VALID] & OK_W64_70) {
if (val[PIO_NO_FLOW] || val[PIO_FLOW]) {
jj = val[CMDS_SUPP_0];
kk = val[CMDS_EN_0];
for (ii = 0; ii < NUM_CMD_FEAT_STR; ii++) {
- if ((jj & 0x8000) && (*cmd_feat_str[ii] != '\0')) {
- printf("\t%s\t%s\n", (kk & 0x8000) ? " *" : "", cmd_feat_str[ii]);
+ const char *feat_str = nth_string(cmd_feat_str, ii);
+ if ((jj & 0x8000) && (*feat_str != '\0')) {
+ printf("\t%s\t%s\n", (kk & 0x8000) ? " *" : "", feat_str);
}
jj <<= 1;
kk <<= 1;
}
/* Removable Media Status Notification feature set */
if ((val[RM_STAT] & RM_STAT_BITS) == RM_STAT_SUP)
- printf("\t%s supported\n", cmd_feat_str[27]);
+ printf("\t%s supported\n", nth_string(cmd_feat_str, 27));
/* security */
if ((eqpt != CDROM) && (like_std > 3)
jj = val[SECU_STATUS];
if (jj) {
for (ii = 0; ii < NUM_SECU_STR; ii++) {
- printf("\t%s\t%s\n", (!(jj & 0x0001)) ? "not" : "", secu_str[ii]);
+ printf("\t%s\t%s\n", (!(jj & 0x0001)) ? "not" : "", nth_string(secu_str, ii));
jj >>=1;
}
if (val[SECU_STATUS] & SECU_ENABLED) {
jj = val[ERASE_TIME] & ERASE_BITS;
kk = val[ENH_ERASE_TIME] & ERASE_BITS;
if (jj || kk) {
- printf("\t");
+ bb_putchar('\t');
if (jj) printf("%umin for %sSECURITY ERASE UNIT. ", jj==ERASE_BITS ? 508 : jj<<1, "");
if (kk) printf("%umin for %sSECURITY ERASE UNIT. ", kk==ERASE_BITS ? 508 : kk<<1, "ENHANCED ");
bb_putchar('\n');
/* reset result */
jj = val[HWRST_RSLT];
if ((jj & VALID) == VALID_VAL) {
- if (!(oo = (jj & RST0)))
+ oo = (jj & RST0);
+ if (!oo)
jj >>= 8;
if ((jj & DEV_DET) == JUMPER_VAL)
strng = " determined by the jumper";
// Too bad, really.
#if ENABLE_FEATURE_HDPARM_GET_IDENTITY
-static const char *const cfg_str[] = {
- "", "HardSect", "SoftSect", "NotMFM",
- "HdSw>15uSec", "SpinMotCtl", "Fixed", "Removeable",
- "DTR<=5Mbs", "DTR>5Mbs", "DTR>10Mbs", "RotSpdTol>.5%",
- "dStbOff", "TrkOff", "FmtGapReq", "nonMagnetic"
-};
+static const char cfg_str[] ALIGN1 =
+ """\0" "HardSect""\0" "SoftSect""\0" "NotMFM""\0"
+ "HdSw>15uSec""\0" "SpinMotCtl""\0" "Fixed""\0" "Removeable""\0"
+ "DTR<=5Mbs""\0" "DTR>5Mbs""\0" "DTR>10Mbs""\0" "RotSpdTol>.5%""\0"
+ "dStbOff""\0" "TrkOff""\0" "FmtGapReq""\0" "nonMagnetic"
+;
-static const char *const BuffType[] = {
- "Unknown", "1Sect", "DualPort", "DualPortCache"
-};
+static const char BuffType[] ALIGN1 =
+ "unknown""\0" "1Sect""\0" "DualPort""\0" "DualPortCache"
+;
static void dump_identity(const struct hd_driveid *id)
{
int i;
- const unsigned short int *id_regs = (const void*) id;
+ const unsigned short *id_regs = (const void*) id;
printf("\n Model=%.40s, FwRev=%.8s, SerialNo=%.20s\n Config={",
id->model, id->fw_rev, id->serial_no);
for (i = 0; i <= 15; i++) {
if (id->config & (1<<i))
- printf(" %s", cfg_str[i]);
+ printf(" %s", nth_string(cfg_str, i));
}
printf(" }\n RawCHS=%u/%u/%u, TrkSize=%u, SectSize=%u, ECCbytes=%u\n"
" BuffType=(%u) %s, BuffSize=%ukB, MaxMultSect=%u",
id->cyls, id->heads, id->sectors, id->track_bytes,
id->sector_bytes, id->ecc_bytes,
- id->buf_type, BuffType[(id->buf_type > 3) ? 0 : id->buf_type],
+ id->buf_type, nth_string(BuffType, (id->buf_type > 3) ? 0 : id->buf_type),
id->buf_size/2, id->max_multsect);
if (id->max_multsect) {
printf(", MultSect=");
if (id->tPIO >= 2) printf("pio2 ");
}
if (id->field_valid & 2) {
- if (id->eide_pio_modes & 1) printf("pio3 ");
- if (id->eide_pio_modes & 2) printf("pio4 ");
- if (id->eide_pio_modes &~3) printf("pio? ");
+ static const masks_labels_t pio_modes = {
+ .masks = { 1, 2, ~3 },
+ .labels = "pio3 \0""pio4 \0""pio? \0",
+ };
+ print_flags(&pio_modes, id->eide_pio_modes);
}
if (id->capability & 1) {
if (id->dma_1word | id->dma_mword) {
+ static const int dma_wmode_masks[] = { 0x100, 1, 0x200, 2, 0x400, 4, 0xf800, 0xf8 };
printf("\n DMA modes: ");
- if (id->dma_1word & 0x100) printf("*");
- if (id->dma_1word & 1) printf("sdma0 ");
- if (id->dma_1word & 0x200) printf("*");
- if (id->dma_1word & 2) printf("sdma1 ");
- if (id->dma_1word & 0x400) printf("*");
- if (id->dma_1word & 4) printf("sdma2 ");
- if (id->dma_1word & 0xf800) printf("*");
- if (id->dma_1word & 0xf8) printf("sdma? ");
- if (id->dma_mword & 0x100) printf("*");
- if (id->dma_mword & 1) printf("mdma0 ");
- if (id->dma_mword & 0x200) printf("*");
- if (id->dma_mword & 2) printf("mdma1 ");
- if (id->dma_mword & 0x400) printf("*");
- if (id->dma_mword & 4) printf("mdma2 ");
- if (id->dma_mword & 0xf800) printf("*");
- if (id->dma_mword & 0xf8) printf("mdma? ");
+ print_flags_separated(dma_wmode_masks,
+ "*\0""sdma0 \0""*\0""sdma1 \0""*\0""sdma2 \0""*\0""sdma? \0",
+ id->dma_1word, NULL);
+ print_flags_separated(dma_wmode_masks,
+ "*\0""mdma0\0""*\0""mdma1\0""*\0""mdma2\0""*\0""mdma?\0",
+ id->dma_mword, NULL);
}
}
if (((id->capability & 8) || (id->field_valid & 2)) && id->field_valid & 4) {
+ static const masks_labels_t ultra_modes1 = {
+ .masks = { 0x100, 0x001, 0x200, 0x002, 0x400, 0x004 },
+ .labels = "*\0""udma0 \0""*\0""udma1 \0""*\0""udma2 \0",
+ };
+
printf("\n UDMA modes: ");
- if (id->dma_ultra & 0x100) printf("*");
- if (id->dma_ultra & 0x001) printf("udma0 ");
- if (id->dma_ultra & 0x200) printf("*");
- if (id->dma_ultra & 0x002) printf("udma1 ");
- if (id->dma_ultra & 0x400) printf("*");
- if (id->dma_ultra & 0x004) printf("udma2 ");
+ print_flags(&ultra_modes1, id->dma_ultra);
#ifdef __NEW_HD_DRIVE_ID
if (id->hw_config & 0x2000) {
#else /* !__NEW_HD_DRIVE_ID */
if (id->word93 & 0x2000) {
#endif /* __NEW_HD_DRIVE_ID */
- if (id->dma_ultra & 0x0800) printf("*");
- if (id->dma_ultra & 0x0008) printf("udma3 ");
- if (id->dma_ultra & 0x1000) printf("*");
- if (id->dma_ultra & 0x0010) printf("udma4 ");
- if (id->dma_ultra & 0x2000) printf("*");
- if (id->dma_ultra & 0x0020) printf("udma5 ");
- if (id->dma_ultra & 0x4000) printf("*");
- if (id->dma_ultra & 0x0040) printf("udma6 ");
- if (id->dma_ultra & 0x8000) printf("*");
- if (id->dma_ultra & 0x0080) printf("udma7 ");
+ static const masks_labels_t ultra_modes2 = {
+ .masks = { 0x0800, 0x0008, 0x1000, 0x0010,
+ 0x2000, 0x0020, 0x4000, 0x0040,
+ 0x8000, 0x0080 },
+ .labels = "*\0""udma3 \0""*\0""udma4 \0"
+ "*\0""udma5 \0""*\0""udma6 \0"
+ "*\0""udma7 \0"
+ };
+ print_flags(&ultra_modes2, id->dma_ultra);
}
}
printf("\n AdvancedPM=%s", (!(id_regs[83] & 8)) ? "no" : "yes");
if ((id->minor_rev_num && id->minor_rev_num <= 31)
|| (id->major_rev_num && id->minor_rev_num <= 31)
) {
- printf("\n Drive conforms to: %s: ", (id->minor_rev_num <= 31) ? minor_str[id->minor_rev_num] : "Unknown");
+ printf("\n Drive conforms to: %s: ", (id->minor_rev_num <= 31) ? nth_string(minor_str, id->minor_rev_num) : "unknown");
if (id->major_rev_num != 0x0000 && /* NOVAL_0 */
id->major_rev_num != 0xFFFF) { /* NOVAL_1 */
for (i = 0; i <= 15; i++) {
xlseek(fd, (off_t) 0, SEEK_SET);
}
-static int read_big_block(/*int fd,*/ char *buf)
+static void read_big_block(/*int fd,*/ char *buf)
{
int i;
- i = read(fd, buf, TIMING_BUF_BYTES);
- if (i != TIMING_BUF_BYTES) {
- bb_error_msg("read(%d bytes) failed (rc=%d)", TIMING_BUF_BYTES, i);
- return 1;
- }
+ xread(fd, buf, TIMING_BUF_BYTES);
/* access all sectors of buf to ensure the read fully completed */
for (i = 0; i < TIMING_BUF_BYTES; i += 512)
buf[i] &= 1;
- return 0;
}
-static unsigned long long do_blkgetsize(/*int fd*/ void)
+static unsigned dev_size_mb(/*int fd*/ void)
{
union {
unsigned long long blksize64;
unsigned blksize32;
} u;
- if (0 == ioctl(fd, BLKGETSIZE64, &u.blksize64)) { // returns bytes
- return u.blksize64 / 512;
+ if (0 == ioctl(fd, BLKGETSIZE64, &u.blksize64)) { // bytes
+ u.blksize64 /= (1024 * 1024);
+ } else {
+ xioctl(fd, BLKGETSIZE, &u.blksize32); // sectors
+ u.blksize64 = u.blksize32 / (2 * 1024);
}
- xioctl(fd, BLKGETSIZE, &u.blksize32); // returns sectors
- return u.blksize32;
+ if (u.blksize64 > UINT_MAX)
+ return UINT_MAX;
+ return u.blksize64;
}
-static void print_timing(unsigned t, double e)
+static void print_timing(unsigned m, unsigned elapsed_us)
{
- if (t >= e) /* more than 1MB/s */
- printf("%4d MB in %.2f seconds = %.2f %cB/sec\n", t, e, t / e, 'M');
- else
- printf("%4d MB in %.2f seconds = %.2f %cB/sec\n", t, e, t / e * 1024, 'k');
+ unsigned sec = elapsed_us / 1000000;
+ unsigned hs = (elapsed_us % 1000000) / 10000;
+
+ printf("%5u MB in %u.%02u seconds = %u kB/s\n",
+ m, sec, hs,
+ /* "| 1" prevents div-by-0 */
+ (unsigned) ((unsigned long long)m * (1024 * 1000000) / (elapsed_us | 1))
+ // ~= (m * 1024) / (elapsed_us / 1000000)
+ // = kb / elapsed_sec
+ );
}
-static void do_time(int flag /*,int fd*/)
-/* flag = 0 time_cache, 1 time_device */
+static void do_time(int cache /*,int fd*/)
+/* cache=1: time cache: repeatedly read N MB at offset 0
+ * cache=0: time device: linear read, starting at offset 0
+ */
{
- static const struct itimerval thousand = {{1000, 0}, {1000, 0}};
-
- struct itimerval itv;
+ unsigned max_iterations, iterations;
+ unsigned start; /* doesn't need to be long long */
unsigned elapsed, elapsed2;
- unsigned max_iterations, total_MB, iterations;
+ unsigned total_MB;
char *buf = xmalloc(TIMING_BUF_BYTES);
- if (mlock(buf, TIMING_BUF_BYTES)) {
- bb_perror_msg("mlock");
- goto quit2;
- }
-
- max_iterations = do_blkgetsize() / (2 * 1024) / TIMING_BUF_MB;
+ if (mlock(buf, TIMING_BUF_BYTES))
+ bb_perror_msg_and_die("mlock");
- /* Clear out the device request queues & give them time to complete */
+ /* Clear out the device request queues & give them time to complete.
+ * NB: *small* delay. User is expected to have a clue and to not run
+ * heavy io in parallel with measurements. */
sync();
- sleep(2);
- if (flag == 0) { /* Time cache */
+ sleep(1);
+ if (cache) { /* Time cache */
seek_to_zero();
- if (read_big_block(buf))
- goto quit;
- printf(" Timing buffer-cache reads: ");
+ read_big_block(buf);
+ printf("Timing buffer-cache reads: ");
} else { /* Time device */
- printf(" Timing buffered disk reads: ");
+ printf("Timing buffered disk reads:");
}
fflush(stdout);
- iterations = 0;
- /*
- * getitimer() is used rather than gettimeofday() because
- * it is much more consistent (on my machine, at least).
- */
-//TODO: get rid of
- setitimer(ITIMER_REAL, &thousand, NULL);
+
/* Now do the timing */
+ iterations = 0;
+ /* Max time to run (small for cache, avoids getting
+ * huge total_MB which can overlow unsigned type) */
+ elapsed2 = 510000; /* cache */
+ max_iterations = UINT_MAX;
+ if (!cache) {
+ elapsed2 = 3000000; /* not cache */
+ /* Don't want to read past the end! */
+ max_iterations = dev_size_mb() / TIMING_BUF_MB;
+ }
+ start = monotonic_us();
do {
- ++iterations;
- if (flag == 0)
+ if (cache)
seek_to_zero();
- if (read_big_block(buf))
- goto quit;
- getitimer(ITIMER_REAL, &itv);
- elapsed = (1000 - itv.it_value.tv_sec) * 1000000
- - itv.it_value.tv_usec;
- } while (elapsed < 3000000 && iterations < max_iterations);
+ read_big_block(buf);
+ elapsed = (unsigned)monotonic_us() - start;
+ ++iterations;
+ } while (elapsed < elapsed2 && iterations < max_iterations);
total_MB = iterations * TIMING_BUF_MB;
- if (flag == 0) {
- /* Now remove the lseek() and getitimer() overheads from the elapsed time */
- setitimer(ITIMER_REAL, &thousand, NULL);
+ //printf(" elapsed:%u iterations:%u ", elapsed, iterations);
+ if (cache) {
+ /* Cache: remove lseek() and monotonic_us() overheads
+ * from elapsed */
+ start = monotonic_us();
do {
seek_to_zero();
- getitimer(ITIMER_REAL, &itv);
- elapsed2 = (1000 - itv.it_value.tv_sec) * 1000000
- - itv.it_value.tv_usec;
+ elapsed2 = (unsigned)monotonic_us() - start;
} while (--iterations);
+ //printf(" elapsed2:%u ", elapsed2);
elapsed -= elapsed2;
- total_MB *= BUFCACHE_FACTOR;
+ total_MB *= 2; // BUFCACHE_FACTOR (why?)
flush_buffer_cache();
}
- print_timing(total_MB, elapsed / 1000000.0);
- quit:
+ print_timing(total_MB, elapsed);
munlock(buf, TIMING_BUF_BYTES);
- quit2:
free(buf);
}
#endif
#ifdef HDIO_DRIVE_CMD
-static void interpret_standby(unsigned standby)
+static void interpret_standby(uint8_t standby)
{
- unsigned t;
-
printf(" (");
- if (standby == 0)
+ if (standby == 0) {
printf("off");
- else if (standby == 252)
- printf("21 minutes");
- else if (standby == 253)
- printf("vendor-specific");
- else if (standby == 254)
- printf("Reserved");
- else if (standby == 255)
- printf("21 minutes + 15 seconds");
- else if (standby <= 240) {
- t = standby * 5;
- printf("%u minutes + %u seconds", t / 60, t % 60);
+ } else if (standby <= 240 || standby == 252 || standby == 255) {
+ /* standby is in 5 sec units */
+ printf("%u minutes %u seconds", standby / 12, (standby*5) % 60);
} else if (standby <= 251) {
- t = (standby - 240) * 30;
- printf("%u hours + %u minutes", t / 60, t % 60);
- } else
- printf("illegal value");
+ unsigned t = (standby - 240); /* t is in 30 min units */;
+ printf("%u.%c hours", t / 2, (t & 1) ? '0' : '5');
+ }
+ if (standby == 253)
+ printf("vendor-specific");
+ if (standby == 254)
+ printf("reserved");
printf(")\n");
}
static int translate_xfermode(const char *name)
{
- int val, i;
+ int val;
+ unsigned i;
for (i = 0; i < ARRAY_SIZE(xfermode_val); i++) {
if (!strncmp(name, xfermode_name[i], 5))
else if (xfermode >= 64 && xfermode <= 71)
printf("UltraDMA mode%u", xfermode - 64);
else
- printf("Unknown");
+ printf("unknown");
printf(")\n");
}
#endif /* HDIO_DRIVE_CMD */
ioctl_or_warn(fd, HDIO_SET_DMA, (int *)dma);
}
#endif /* FEATURE_HDPARM_HDIO_GETSET_DMA */
+#ifdef HDIO_SET_QDMA
if (set_dma_q) {
print_flag_on_off(get_dma_q, "DMA queue_depth", dma_q);
ioctl_or_warn(fd, HDIO_SET_QDMA, (int *)dma_q);
}
+#endif
if (set_nowerr) {
print_flag_on_off(get_nowerr, "nowerr", nowerr);
ioctl_or_warn(fd, HDIO_SET_NOWERR, (int *)nowerr);
#ifndef WIN_FLUSHCACHE
#define WIN_FLUSHCACHE 0xe7
#endif
- static unsigned char flushcache[4] = { WIN_FLUSHCACHE, 0, 0, 0 };
#endif /* DO_FLUSHCACHE */
args[2] = wcache ? 0x02 : 0x82;
print_flag_on_off(get_wcache, "drive write-caching", wcache);
char buf[512];
flush_buffer_cache();
if (-1 == read(fd, buf, sizeof(buf)))
- bb_perror_msg("read(%d bytes) failed (rc=%d)", sizeof(buf), -1);
+ bb_perror_msg("read(%d bytes) failed (rc=-1)", sizeof(buf));
}
#endif /* HDIO_DRIVE_CMD */
}
}
if (get_unmask) {
- if(!ioctl_or_warn(fd, HDIO_GET_UNMASKINTR, (unsigned long *)parm))
+ if (!ioctl_or_warn(fd, HDIO_GET_UNMASKINTR, &parm))
print_value_on_off("unmaskirq", parm);
}
}
}
#endif
+#ifdef HDIO_GET_QDMA
if (get_dma_q) {
- if(!ioctl_or_warn(fd, HDIO_GET_QDMA, (unsigned long *)parm))
+ if (!ioctl_or_warn(fd, HDIO_GET_QDMA, &parm))
print_value_on_off("queue_depth", parm);
}
+#endif
if (get_keep) {
- if(!ioctl_or_warn(fd, HDIO_GET_KEEPSETTINGS, (unsigned long *)parm))
+ if (!ioctl_or_warn(fd, HDIO_GET_KEEPSETTINGS, &parm))
print_value_on_off("keepsettings", parm);
}
if (get_nowerr) {
- if(!ioctl_or_warn(fd, HDIO_GET_NOWERR, (unsigned long *)parm))
+ if (!ioctl_or_warn(fd, HDIO_GET_NOWERR, &parm))
print_value_on_off("nowerr", parm);
}
if (get_readonly) {
- if(!ioctl_or_warn(fd, BLKROGET, (unsigned long *)parm))
+ if (!ioctl_or_warn(fd, BLKROGET, &parm))
print_value_on_off("readonly", parm);
}
if (get_readahead) {
- if(!ioctl_or_warn(fd, BLKRAGET, (unsigned long *)parm))
+ if (!ioctl_or_warn(fd, BLKRAGET, &parm))
print_value_on_off("readahead", parm);
}
if (get_geom) {
ioctl_or_warn(fd, BLKRRPART, NULL);
if (do_ctimings)
- do_time(0 /*,fd*/); /* time cache */
+ do_time(1 /*,fd*/); /* time cache */
if (do_timings)
- do_time(1 /*,fd*/); /* time device */
+ do_time(0 /*,fd*/); /* time device */
if (do_flush)
flush_buffer_cache();
close(fd);
bb_error_msg_and_die("bad char: '%c' 0x%02x", c, c);
}
-static void identify_from_stdin(void) ATTRIBUTE_NORETURN;
+static void identify_from_stdin(void) NORETURN;
static void identify_from_stdin(void)
{
uint16_t sbuf[256];
unsigned char *b = (unsigned char *)buf;
int i;
- xread(0, buf, 1280);
+ xread(STDIN_FILENO, buf, 1280);
// Convert the newline-separated hex data into an identify block.
/*-------------------------------------*/
/* our main() routine: */
-int hdparm_main(int argc, char **argv);
+int hdparm_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
int hdparm_main(int argc, char **argv)
{
int c;
do_flush |= do_timings |= (c == 't');
do_flush |= do_ctimings |= (c == 'T');
#ifdef HDIO_DRIVE_CMD
- if (c == 'S') parse_opts(&get_standby, &set_standby, &standby_requested, 0, INT_MAX);
+ if (c == 'S') parse_opts(&get_standby, &set_standby, &standby_requested, 0, 255);
if (c == 'D') parse_opts(&get_defects, &set_defects, &defects, 0, INT_MAX);
if (c == 'P') parse_opts(&get_prefetch, &set_prefetch, &prefetch, 0, INT_MAX);
parse_xfermode((c == 'X'), &get_xfermode, &set_xfermode, &xfermode_requested);