Changeset 2725 in MondoRescue for branches/2.2.9/mindi-busybox/miscutils/hdparm.c

Timestamp:

Feb 25, 2011, 9:26:54 PM (13 years ago)

Author:

Bruno Cornec

Message:

• Update mindi-busybox to 1.18.3 to avoid problems with the tar command which is now failing on recent versions with busybox 1.7.3

File:

• branches/2.2.9/mindi-busybox/miscutils/hdparm.c (modified) (68 diffs)

branches/2.2.9/mindi-busybox/miscutils/hdparm.c

@@ -6 +6 @@
  * Hacked by Tito <farmatito@tiscali.it> for size optimization.
  *
- * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  *
  * This program is based on the source code of hdparm: see below...
@@ -12 +12 @@
  *          - by Mark Lord (C) 1994-2002 -- freely distributable
  */
-
 #include "libbb.h"
+/* must be _after_ libbb.h: */
 #include <linux/hdreg.h>
+#include <sys/mount.h>
+#if !defined(BLKGETSIZE64)
+# define BLKGETSIZE64 _IOR(0x12,114,size_t)
+#endif
 
 /* device types */
@@ -60 +64 @@
                     /* 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 */
@@ -83 +87 @@
 #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) */
@@ -128 +132 @@
 #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 */
@@ -239 +187 @@
 /* word 81: minor version number */
 #define MINOR_MAX       0x22
+/* 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 CMDS_W84        0x002f  /* word 83: defined command locations*/
+#define SUPPORT_48_BIT      0x0400
+#define NUM_CMD_FEAT_STR    48
+
+/* words 85-87: cmds/feats enabled */
+/* use cmd_feat_str[] to display what commands and features have
+ * been enabled with words 85-87
+ */
+
+/* words 89, 90, SECU ERASE TIME */
+#define ERASE_BITS      0x00ff
+
+/* word 92: master password revision */
+/* NOVAL_0 or  NOVAL_1 means no support for master password revision */
+
+/* word 93: hw reset result */
+#define CBLID           0x2000  /* CBLID status */
+#define RST0            0x0001  /* 1=reset to device #0 */
+#define DEV_DET         0x0006  /* how device num determined */
+#define JUMPER_VAL      0x0002  /* device num determined by jumper */
+#define CSEL_VAL        0x0004  /* device num determined by CSEL_VAL */
+
+/* word 127: removable media status notification feature set support */
+#define RM_STAT_BITS    0x0003
+#define RM_STAT_SUP     0x0001
+
+/* word 128: security */
+#define SECU_ENABLED    0x0002
+#define SECU_LEVEL      0x0010
+#define NUM_SECU_STR    6
+
+/* word 160: CFA power mode */
+#define VALID_W160              0x8000  /* 1=word valid */
+#define PWR_MODE_REQ            0x2000  /* 1=CFA power mode req'd by some cmds*/
+#define PWR_MODE_OFF            0x1000  /* 1=CFA power moded disabled */
+#define MAX_AMPS                0x0fff  /* value = max current in ma */
+
+/* word 255: integrity */
+#define SIG                     0x00ff  /* signature location */
+#define SIG_VAL                 0x00a5  /* signature value */
+
+#define TIMING_BUF_MB           1
+#define TIMING_BUF_BYTES        (TIMING_BUF_MB * 1024 * 1024)
+
+#undef DO_FLUSHCACHE            /* under construction: force cache flush on -W0 */
+
+
+#define IS_GET 1
+#define IS_SET 2
+
+
+enum { fd = 3 };
+
+
+struct globals {
+    smallint get_identity, get_geom;
+    smallint do_flush;
+    smallint do_ctimings, do_timings;
+    smallint reread_partn;
+    smallint set_piomode, noisy_piomode;
+    smallint getset_readahead;
+    smallint getset_readonly;
+    smallint getset_unmask;
+    smallint getset_mult;
+#ifdef HDIO_GET_QDMA
+    smallint getset_dma_q;
+#endif
+    smallint getset_nowerr;
+    smallint getset_keep;
+    smallint getset_io32bit;
+    int piomode;
+    unsigned long Xreadahead;
+    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;
+#if ENABLE_FEATURE_HDPARM_HDIO_GETSET_DMA
+    unsigned long dma;
+    smallint getset_dma;
+#endif
+#ifdef HDIO_DRIVE_CMD
+    smallint set_xfermode, get_xfermode;
+    smallint getset_dkeep;
+    smallint getset_standby;
+    smallint getset_lookahead;
+    smallint getset_prefetch;
+    smallint getset_defects;
+    smallint getset_wcache;
+    smallint getset_doorlock;
+    smallint set_seagate;
+    smallint set_standbynow;
+    smallint set_sleepnow;
+    smallint get_powermode;
+    smallint getset_apmmode;
+    int xfermode_requested;
+    unsigned long dkeep;
+    unsigned long standby_requested; /* 0..255 */
+    unsigned long lookahead;
+    unsigned long prefetch;
+    unsigned long defects;
+    unsigned long wcache;
+    unsigned long doorlock;
+    unsigned long apmmode;
+#endif
+    IF_FEATURE_HDPARM_GET_IDENTITY(        smallint get_IDentity;)
+    IF_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(  smallint getset_busstate;)
+    IF_FEATURE_HDPARM_HDIO_DRIVE_RESET(    smallint perform_reset;)
+    IF_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(  smallint perform_tristate;)
+    IF_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF(smallint unregister_hwif;)
+    IF_FEATURE_HDPARM_HDIO_SCAN_HWIF(      smallint scan_hwif;)
+    IF_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(  unsigned long busstate;)
+    IF_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(  unsigned long tristate;)
+    IF_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF(unsigned long hwif;)
+#if ENABLE_FEATURE_HDPARM_HDIO_SCAN_HWIF
+    unsigned long hwif_data;
+    unsigned long hwif_ctrl;
+    unsigned long hwif_irq;
+#endif
+#ifdef DO_FLUSHCACHE
+    unsigned char flushcache[4] = { WIN_FLUSHCACHE, 0, 0, 0 };
+#endif
+} FIX_ALIASING;
+#define G (*(struct globals*)&bb_common_bufsiz1)
+struct BUG_G_too_big {
+    char BUG_G_too_big[sizeof(G) <= COMMON_BUFSIZE ? 1 : -1];
+};
+#define get_identity       (G.get_identity           )
+#define get_geom           (G.get_geom               )
+#define do_flush           (G.do_flush               )
+#define do_ctimings        (G.do_ctimings            )
+#define do_timings         (G.do_timings             )
+#define reread_partn       (G.reread_partn           )
+#define set_piomode        (G.set_piomode            )
+#define noisy_piomode      (G.noisy_piomode          )
+#define getset_readahead   (G.getset_readahead       )
+#define getset_readonly    (G.getset_readonly        )
+#define getset_unmask      (G.getset_unmask          )
+#define getset_mult        (G.getset_mult            )
+#define getset_dma_q       (G.getset_dma_q           )
+#define getset_nowerr      (G.getset_nowerr          )
+#define getset_keep        (G.getset_keep            )
+#define getset_io32bit     (G.getset_io32bit         )
+#define piomode            (G.piomode                )
+#define Xreadahead         (G.Xreadahead             )
+#define readonly           (G.readonly               )
+#define unmask             (G.unmask                 )
+#define mult               (G.mult                   )
+#define dma_q              (G.dma_q                  )
+#define nowerr             (G.nowerr                 )
+#define keep               (G.keep                   )
+#define io32bit            (G.io32bit                )
+#define dma                (G.dma                    )
+#define getset_dma         (G.getset_dma             )
+#define set_xfermode       (G.set_xfermode           )
+#define get_xfermode       (G.get_xfermode           )
+#define getset_dkeep       (G.getset_dkeep           )
+#define getset_standby     (G.getset_standby         )
+#define getset_lookahead   (G.getset_lookahead       )
+#define getset_prefetch    (G.getset_prefetch        )
+#define getset_defects     (G.getset_defects         )
+#define getset_wcache      (G.getset_wcache          )
+#define getset_doorlock    (G.getset_doorlock        )
+#define set_seagate        (G.set_seagate            )
+#define set_standbynow     (G.set_standbynow         )
+#define set_sleepnow       (G.set_sleepnow           )
+#define get_powermode      (G.get_powermode          )
+#define getset_apmmode     (G.getset_apmmode         )
+#define xfermode_requested (G.xfermode_requested     )
+#define dkeep              (G.dkeep                  )
+#define standby_requested  (G.standby_requested      )
+#define lookahead          (G.lookahead              )
+#define prefetch           (G.prefetch               )
+#define defects            (G.defects                )
+#define wcache             (G.wcache                 )
+#define doorlock           (G.doorlock               )
+#define apmmode            (G.apmmode                )
+#define get_IDentity       (G.get_IDentity           )
+#define getset_busstate    (G.getset_busstate        )
+#define perform_reset      (G.perform_reset          )
+#define perform_tristate   (G.perform_tristate       )
+#define unregister_hwif    (G.unregister_hwif        )
+#define scan_hwif          (G.scan_hwif              )
+#define busstate           (G.busstate               )
+#define tristate           (G.tristate               )
+#define hwif               (G.hwif                   )
+#define hwif_data          (G.hwif_data              )
+#define hwif_ctrl          (G.hwif_ctrl              )
+#define hwif_irq           (G.hwif_irq               )
+
+
+/* Busybox messages and functions */
+#if ENABLE_IOCTL_HEX2STR_ERROR
+static int ioctl_alt_func(/*int fd,*/ int cmd, unsigned char *args, int alt, const char *string)
+{
+    if (!ioctl(fd, cmd, args))
+        return 0;
+    args[0] = alt;
+    return bb_ioctl_or_warn(fd, cmd, args, string);
+}
+#define ioctl_alt_or_warn(cmd,args,alt) ioctl_alt_func(cmd,args,alt,#cmd)
+#else
+static int ioctl_alt_func(/*int fd,*/ int cmd, unsigned char *args, int alt)
+{
+    if (!ioctl(fd, cmd, args))
+        return 0;
+    args[0] = alt;
+    return bb_ioctl_or_warn(fd, cmd, args);
+}
+#define ioctl_alt_or_warn(cmd,args,alt) ioctl_alt_func(cmd,args,alt)
+#endif
+
+static void on_off(int value)
+{
+    puts(value ? " (on)" : " (off)");
+}
+
+static void print_flag_on_off(int get_arg, const char *s, unsigned long arg)
+{
+    if (get_arg) {
+        printf(" setting %s to %ld", s, arg);
+        on_off(arg);
+    }
+}
+
+static void print_value_on_off(const char *str, unsigned long argp)
+{
+    printf(" %s\t= %2ld", str, argp);
+    on_off(argp != 0);
+}
+
 #if ENABLE_FEATURE_HDPARM_GET_IDENTITY
-static const char *const minor_str[MINOR_MAX + 2] = {
+static void print_ascii(const char *p, int length)
+{
+#if BB_BIG_ENDIAN
+#define LE_ONLY(x)
+    enum { ofs = 0 };
+#else
+#define LE_ONLY(x) x
+    /* every 16bit word is big-endian (i.e. inverted) */
+    /* accessing bytes in 1,0, 3,2, 5,4... sequence */
+    int ofs = 1;
+#endif
+
+    length *= 2;
+    /* find first non-space & print it */
+    while (length && p[ofs] != ' ') {
+        p++;
+        LE_ONLY(ofs = -ofs;)
+        length--;
+    }
+    while (length && p[ofs]) {
+        bb_putchar(p[ofs]);
+        p++;
+        LE_ONLY(ofs = -ofs;)
+        length--;
+    }
+    bb_putchar('\n');
+#undef LE_ONLY
+}
+
+static void xprint_ascii(uint16_t *val, int i, const char *string, int n)
+{
+    if (val[i]) {
+        printf("\t%-20s", string);
+        print_ascii((void*)&val[i], n);
+    }
+}
+
+static uint8_t mode_loop(uint16_t mode_sup, uint16_t mode_sel, int cc, uint8_t *have_mode)
+{
+    uint16_t ii;
+    uint8_t err_dma = 0;
+
+    for (ii = 0; ii <= MODE_MAX; ii++) {
+        if (mode_sel & 0x0001) {
+            printf("*%cdma%u ", cc, ii);
+            if (*have_mode)
+                err_dma = 1;
+            *have_mode = 1;
+        } else if (mode_sup & 0x0001)
+            printf("%cdma%u ", cc, ii);
+
+        mode_sup >>= 1;
+        mode_sel >>= 1;
+    }
+    return err_dma;
+}
+
+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",                                  /* 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
+    "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: */
@@ -320 +600 @@
 };
 
-/* 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 CMDS_W84        0x002f  /* 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 */
-};
-
-static void identify(uint16_t *id_supplied) ATTRIBUTE_NORETURN;
-static void identify_from_stdin(void) ATTRIBUTE_NORETURN;
-#else
-void identify_from_stdin(void);
-#endif
-
-
-/* words 85-87: cmds/feats enabled */
-/* use cmd_feat_str[] to display what commands and features have
- * been enabled with words 85-87
- */
-
-/* words 89, 90, SECU ERASE TIME */
-#define ERASE_BITS      0x00ff
-
-/* word 92: master password revision */
-/* NOVAL_0 or  NOVAL_1 means no support for master password revision */
-
-/* word 93: hw reset result */
-#define CBLID           0x2000  /* CBLID status */
-#define RST0            0x0001  /* 1=reset to device #0 */
-#define DEV_DET         0x0006  /* how device num determined */
-#define JUMPER_VAL      0x0002  /* device num determined by jumper */
-#define CSEL_VAL        0x0004  /* device num determined by CSEL_VAL */
-
-/* word 127: removable media status notification feature set support */
-#define RM_STAT_BITS    0x0003
-#define RM_STAT_SUP     0x0001
-
-/* word 128: security */
-#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 PWR_MODE_REQ            0x2000  /* 1=CFA power mode req'd by some cmds*/
-#define PWR_MODE_OFF            0x1000  /* 1=CFA power moded disabled */
-#define MAX_AMPS                0x0fff  /* value = max current in ma */
-
-/* word 255: integrity */
-#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 */
-
-/* Busybox messages and functions */
-#if ENABLE_IOCTL_HEX2STR_ERROR
-static int ioctl_alt_func(int fd, int cmd, unsigned char *args, int alt, const char *string)
-{
-    if (!ioctl(fd, cmd, args))
-        return 0;
-    args[0] = alt;
-    return bb_ioctl_or_warn(fd, cmd, args, string);
-}
-#define ioctl_alt_or_warn(fd,cmd,args,alt) ioctl_alt_func(fd,cmd,args,alt,#cmd)
-#else
-static int ioctl_alt_func(int fd, int cmd, unsigned char *args, int alt)
-{
-    if (!ioctl(fd, cmd, args))
-        return 0;
-    args[0] = alt;
-    return bb_ioctl_or_warn(fd, cmd, args);
-}
-#define ioctl_alt_or_warn(fd,cmd,args,alt) ioctl_alt_func(fd,cmd,args,alt)
-#endif
-
-static void on_off(int value)
-{
-    puts(value ? " (on)" : " (off)");
-}
-
-static void print_flag_on_off(int get_arg, const char *s, unsigned long arg)
-{
-    if (get_arg) {
-        printf(" setting %s to %ld", s, arg);
-        on_off(arg);
-    }
-}
-
-static void print_value_on_off(const char *str, unsigned long argp)
-{
-    printf(" %s\t= %2ld", str, argp);
-    on_off(argp != 0);
-}
-
-#if ENABLE_FEATURE_HDPARM_GET_IDENTITY
-static void print_ascii(uint16_t *p, uint8_t length);
-
-static void xprint_ascii(uint16_t *val, int i, const char *string, int n)
-{
-    if (val[i]) {
-        printf("\t%-20s", string);
-        print_ascii(&val[i], n);
-    }
-}
-#endif
-/* end of busybox specific stuff */
-
-#if ENABLE_FEATURE_HDPARM_GET_IDENTITY
-static uint8_t mode_loop(uint16_t mode_sup, uint16_t mode_sel, int cc, uint8_t *have_mode)
-{
-    uint16_t ii;
-    uint8_t err_dma = 0;
-
-    for (ii = 0; ii <= MODE_MAX; ii++) {
-        if (mode_sel & 0x0001) {
-            printf("*%cdma%u ", cc, ii);
-            if (*have_mode)
-                err_dma = 1;
-            *have_mode = 1;
-        } else if (mode_sup & 0x0001)
-            printf("%cdma%u ", cc, ii);
-
-        mode_sup >>= 1;
-        mode_sel >>= 1;
-    }
-    return err_dma;
-}
-
-static void print_ascii(uint16_t *p, uint8_t length)
-{
-    uint8_t ii;
-    char cl;
-
-    /* find first non-space & print it */
-    for (ii = 0; ii < length; ii++) {
-        if ((char)((*p)>>8) != ' ')
-            break;
-        cl = (char)(*p);
-        if (cl != ' ') {
-            if (cl != '\0')
-                printf("%c", cl);
-            p++;
-            ii++;
-            break;
-        }
-        p++;
-    }
-    /* print the rest */
-    for (; ii< length; ii++) {
-        if (!(*p))
-            break; /* some older devices have NULLs */
-        printf("%c%c", (char)((*p)>>8), (char)(*p));
-        p++;
-    }
-    puts("");
-}
+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 *id_supplied)
-{
-    uint16_t buf[256];
-    uint16_t *val, ii, jj, kk;
+static void identify(uint16_t *val) NORETURN;
+static void identify(uint16_t *val)
+{
+    uint16_t ii, jj, kk;
     uint16_t like_std = 1, std = 0, min_std = 0xffff;
     uint16_t dev = NO_DEV, eqpt = NO_DEV;
@@ -558 +674 @@
     uint64_t bbbig; /* (:) */
     const char *strng;
-
-    // Adjust for endianness if necessary.
-
-    if (BB_BIG_ENDIAN) {
-        swab(id_supplied, buf, sizeof(buf));
-        val = buf;
-    } else
-        val = id_supplied;
-
-    chksum &= 0xff;
-
-    /* check if we recognise the device type */
-    puts("");
+#if BB_BIG_ENDIAN
+    uint16_t buf[256];
+
+    // Adjust for endianness
+    swab(val, buf, sizeof(buf));
+    val = buf;
+#endif
+    /* check if we recognize the device type */
+    bb_putchar('\n');
     if (!(val[GEN_CONFIG] & NOT_ATA)) {
         dev = ATA_DEV;
@@ -581 +693 @@
         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");
 
@@ -619 +731 @@
             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;
@@ -687 +799 @@
             printf("& some of %u\n", like_std);
         else
-            puts("");
+            bb_putchar('\n');
     } else {
         /* TBD: do CDROM stuff more thoroughly.  For now... */
@@ -704 +816 @@
             }
         }
-        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;
@@ -718 +830 @@
         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;
         }
@@ -730 +842 @@
             strng ="50us";
         else
-            strng = "Unknown";
+            strng = "unknown";
         printf("\tDRQ response: %s\n\tPacket size: ", strng); /* Data Request (DRQ) */
 
@@ -738 +850 @@
             strng = "16 bytes";
         else
-            strng = "Unknown";
+            strng = "unknown";
         puts(strng);
     } else {
         /* addressing...CHS? See section 6.2 of ATA specs 4 or 5 */
         ll = (uint32_t)val[LBA_SECTS_MSB] << 16 | val[LBA_SECTS_LSB];
-        mm = 0; bbbig = 0;
+        mm = 0;
+        bbbig = 0;
         if ((ll > 0x00FBFC10) && (!val[LCYLS]))
             printf("\tCHS addressing not supported\n");
         else {
             jj = val[WHATS_VALID] & OK_W54_58;
-            printf("\tLogical\t\tmax\tcurrent\n\tcylinders\t%u\t%u\n\theads\t\t%u\t%u\n\tsectors/track\t%u\t%u\n\t--\n",
-                    val[LCYLS],jj?val[LCYLS_CUR]:0, val[LHEADS],jj?val[LHEADS_CUR]:0, val[LSECTS],jj?val[LSECTS_CUR]:0);
+            printf("\tLogical\t\tmax\tcurrent\n"
+                "\tcylinders\t%u\t%u\n"
+                "\theads\t\t%u\t%u\n"
+                "\tsectors/track\t%u\t%u\n"
+                "\t--\n",
+                val[LCYLS],
+                jj ? val[LCYLS_CUR] : 0,
+                val[LHEADS],
+                jj ? val[LHEADS_CUR] : 0,
+                val[LSECTS],
+                jj ? val[LSECTS_CUR] : 0);
 
             if ((min_std == 1) && (val[TRACK_BYTES] || val[SECT_BYTES]))
-                printf("\tbytes/track: %u\tbytes/sector: %u\n", val[TRACK_BYTES], val[SECT_BYTES]);
+                printf("\tbytes/track: %u\tbytes/sector: %u\n",
+                    val[TRACK_BYTES], val[SECT_BYTES]);
 
             if (jj) {
@@ -787 +910 @@
             printf("(%"PRIu64" GB)\n", bbbig/1000);
         else
-            puts("");
+            bb_putchar('\n');
     }
 
@@ -794 +917 @@
 
     if (dev == ATAPI_DEV) {
-        if (eqpt != CDROM && (val[CAPAB_0] & CMD_Q_SUP)) printf("Cmd queuing, ");
-        if (val[CAPAB_0] & OVLP_SUP) printf("Cmd overlap, ");
+        if (eqpt != CDROM && (val[CAPAB_0] & CMD_Q_SUP))
+            printf("Cmd queuing, ");
+        if (val[CAPAB_0] & OVLP_SUP)
+            printf("Cmd overlap, ");
     }
     if (val[CAPAB_0] & LBA_SUP) printf("LBA, ");
@@ -801 +926 @@
     if (like_std != 1) {
         printf("IORDY%s(can%s be disabled)\n",
-                !(val[CAPAB_0] & IORDY_SUP) ? "(may be)" : "",
-                (val[CAPAB_0] & IORDY_OFF) ? "" :"not");
+            !(val[CAPAB_0] & IORDY_SUP) ? "(may be)" : "",
+            (val[CAPAB_0] & IORDY_OFF) ? "" :"not");
     } else
         printf("no IORDY\n");
@@ -808 +933 @@
     if ((like_std == 1) && val[BUF_TYPE]) {
         printf("\tBuffer type: %04x: %s%s\n", val[BUF_TYPE],
-                (val[BUF_TYPE] < 2) ? "single port, single-sector" : "dual port, multi-sector",
-                (val[BUF_TYPE] > 2) ? " with read caching ability" : "");
+            (val[BUF_TYPE] < 2) ? "single port, single-sector" : "dual port, multi-sector",
+            (val[BUF_TYPE] > 2) ? " with read caching ability" : "");
     }
 
@@ -826 +951 @@
             printf("\tCan%s perform double-word IO\n", (!val[DWORD_IO]) ? "not" : "");
         else {
-            printf("\tStandby timer values: spec'd by %s", (val[CAPAB_0] & STD_STBY) ? "Standard" : "Vendor");
+            printf("\tStandby timer values: spec'd by %s",
+                (val[CAPAB_0] & STD_STBY) ? "standard" : "vendor");
             if ((like_std > 3) && ((val[CAPAB_1] & VALID) == VALID_VAL))
-                printf(", %s device specific minimum\n", (val[CAPAB_1] & MIN_STANDBY_TIMER) ? "with" : "no");
+                printf(", %s device specific minimum\n",
+                    (val[CAPAB_1] & MIN_STANDBY_TIMER) ? "with" : "no");
             else
-                puts("");
+                bb_putchar('\n');
         }
         printf("\tR/W multiple sector transfer: ");
@@ -856 +983 @@
         if (like_std > 5 && val[ACOUSTIC]) {
             printf("\tRecommended acoustic management value: %u, current value: %u\n",
-                    (val[ACOUSTIC] >> 8) & 0x00ff, val[ACOUSTIC] & 0x00ff);
+                (val[ACOUSTIC] >> 8) & 0x00ff,
+                val[ACOUSTIC] & 0x00ff);
         }
     } else {
@@ -865 +993 @@
         if (val[PKT_REL] || val[SVC_NBSY]) {
             printf("\tOverlap support:");
-            if (val[PKT_REL]) printf(" %uus to release bus.", val[PKT_REL]);
-            if (val[SVC_NBSY]) printf(" %uus to clear BSY after SERVICE cmd.", val[SVC_NBSY]);
-            puts("");
+            if (val[PKT_REL])
+                printf(" %uus to release bus.", val[PKT_REL]);
+            if (val[SVC_NBSY])
+                printf(" %uus to clear BSY after SERVICE cmd.",
+                    val[SVC_NBSY]);
+            bb_putchar('\n');
         }
     }
@@ -894 +1025 @@
         }
         if (err_dma || !have_mode) printf("(?)");
-        puts("");
+        bb_putchar('\n');
 
         if ((dev == ATAPI_DEV) && (eqpt != CDROM) && (val[CAPAB_0] & DMA_IL_SUP))
@@ -905 +1036 @@
             if (val[DMA_TIME_MIN]) printf(" min=%uns", val[DMA_TIME_MIN]);
             if (val[DMA_TIME_NORM]) printf(" recommended=%uns", val[DMA_TIME_NORM]);
-            puts("");
+            bb_putchar('\n');
         }
     }
@@ -919 +1050 @@
             jj >>=1;
         }
-        puts("");
+        bb_putchar('\n');
     } else if (((min_std < 5) || (eqpt == CDROM)) && (val[PIO_MODE] & MODE)) {
         for (ii = 0; ii <= val[PIO_MODE]>>8; ii++)
             printf("pio%d ", ii);
-        puts("");
+        bb_putchar('\n');
     } else
-        printf("unknown\n");
+        puts("unknown");
 
     if (val[WHATS_VALID] & OK_W64_70) {
         if (val[PIO_NO_FLOW] || val[PIO_FLOW]) {
             printf("\t\tCycle time:");
-            if (val[PIO_NO_FLOW]) printf(" no flow control=%uns", val[PIO_NO_FLOW]);
-            if (val[PIO_FLOW]) printf("  IORDY flow control=%uns", val[PIO_FLOW]);
-            puts("");
+            if (val[PIO_NO_FLOW])
+                printf(" no flow control=%uns", val[PIO_NO_FLOW]);
+            if (val[PIO_FLOW])
+                printf("  IORDY flow control=%uns", val[PIO_FLOW]);
+            bb_putchar('\n');
         }
     }
 
     if ((val[CMDS_SUPP_1] & VALID) == VALID_VAL) {
-        printf("Commands/features:\n\tEnabled\tSupported:\n");
+        printf("Commands/features:\n"
+            "\tEnabled\tSupported:\n");
         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;
@@ -958 +1093 @@
     /* 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 */
@@ -970 +1105 @@
         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) {
-                printf("\tSecurity level %s\n", (val[SECU_STATUS] & SECU_LEVEL) ? "maximum" : "high");
+                printf("\tSecurity level %s\n",
+                    (val[SECU_STATUS] & SECU_LEVEL) ? "maximum" : "high");
             }
         }
@@ -980 +1118 @@
         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 ");
-            puts("");
+            bb_putchar('\n');
         }
     }
@@ -990 +1128 @@
     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)
@@ -998 +1137 @@
         else
             strng = "";
-        printf("HW reset results:\n\tCBLID- %s Vih\n\tDevice num = %i%s\n",
-                (val[HWRST_RSLT] & CBLID) ? "above" : "below", !(oo), strng);
+        printf("HW reset results:\n"
+            "\tCBLID- %s Vih\n"
+            "\tDevice num = %i%s\n",
+            (val[HWRST_RSLT] & CBLID) ? "above" : "below",
+            !(oo), strng);
     }
 
@@ -1005 +1147 @@
     if ((like_std > 4) && (eqpt != CDROM)) {
         if (val[CFA_PWR_MODE] & VALID_W160) {
-            printf("CFA power mode 1:\n\t%s%s\n", (val[CFA_PWR_MODE] & PWR_MODE_OFF) ? "disabled" : "enabled",
-                    (val[CFA_PWR_MODE] & PWR_MODE_REQ) ? " and required by some commands" : "");
-
+            printf("CFA power mode 1:\n"
+                "\t%s%s\n",
+                (val[CFA_PWR_MODE] & PWR_MODE_OFF) ? "disabled" : "enabled",
+                (val[CFA_PWR_MODE] & PWR_MODE_REQ) ? " and required by some commands" : "");
             if (val[CFA_PWR_MODE] & MAX_AMPS)
                 printf("\tMaximum current = %uma\n", val[CFA_PWR_MODE] & MAX_AMPS);
@@ -1018 +1161 @@
     exit(EXIT_SUCCESS);
 }
-#endif
-
-static smallint get_identity, get_geom;
-static smallint do_flush;
-static smallint do_ctimings, do_timings;
-static smallint reread_partn;
-
-static smallint set_piomode, noisy_piomode;
-static smallint set_readahead, get_readahead;
-static smallint set_readonly, get_readonly;
-static smallint set_unmask, get_unmask;
-static smallint set_mult, get_mult;
-static smallint set_dma_q, get_dma_q;
-static smallint set_nowerr, get_nowerr;
-static smallint set_keep, get_keep;
-static smallint set_io32bit, get_io32bit;
-static int piomode;
-static unsigned long Xreadahead;
-static unsigned long readonly;
-static unsigned long unmask;
-static unsigned long mult;
-static unsigned long dma_q;
-static unsigned long nowerr;
-static unsigned long keep;
-static unsigned long io32bit;
-#if ENABLE_FEATURE_HDPARM_HDIO_GETSET_DMA
-static unsigned long dma;
-static smallint set_dma, get_dma;
-#endif
-#ifdef HDIO_DRIVE_CMD
-static smallint set_xfermode, get_xfermode;
-static smallint set_dkeep, get_dkeep;
-static smallint set_standby, get_standby;
-static smallint set_lookahead, get_lookahead;
-static smallint set_prefetch, get_prefetch;
-static smallint set_defects, get_defects;
-static smallint set_wcache, get_wcache;
-static smallint set_doorlock, get_doorlock;
-static smallint set_seagate, get_seagate;
-static smallint set_standbynow, get_standbynow;
-static smallint set_sleepnow, get_sleepnow;
-static smallint get_powermode;
-static smallint set_apmmode, get_apmmode;
-static int xfermode_requested;
-static unsigned long dkeep;
-static unsigned long standby_requested;
-static unsigned long lookahead;
-static unsigned long prefetch;
-static unsigned long defects;
-static unsigned long wcache;
-static unsigned long doorlock;
-static unsigned long apmmode;
-#endif
-USE_FEATURE_HDPARM_GET_IDENTITY(        static smallint get_IDentity;)
-USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(  static smallint set_busstate, get_busstate;)
-USE_FEATURE_HDPARM_HDIO_DRIVE_RESET(    static smallint perform_reset;)
-USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(  static smallint perform_tristate;)
-USE_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF(static smallint unregister_hwif;)
-USE_FEATURE_HDPARM_HDIO_SCAN_HWIF(      static smallint scan_hwif;)
-USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(  static unsigned long busstate;)
-USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(  static unsigned long tristate;)
-USE_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF(static unsigned long hwif;)
-#if ENABLE_FEATURE_HDPARM_HDIO_SCAN_HWIF
-static unsigned long hwif_data;
-static unsigned long hwif_ctrl;
-static unsigned long hwif_irq;
 #endif
 
@@ -1098 +1175 @@
 
 #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 *const BuffType[] = {
-    "Unknown", "1Sect", "DualPort", "DualPortCache"
-};
-
-static void dump_identity(const struct hd_driveid *id)
+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 BuffType[] ALIGN1 =
+    "unknown""\0"     "1Sect""\0"      "DualPort""\0"  "DualPortCache"
+;
+
+static NOINLINE 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={",
@@ -1118 +1195 @@
     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_size/2, id->max_multsect);
+        " 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,
+        nth_string(BuffType, (id->buf_type > 3) ? 0 : id->buf_type),
+        id->buf_size/2, id->max_multsect);
     if (id->max_multsect) {
         printf(", MultSect=");
@@ -1135 +1213 @@
             printf("off");
     }
-    puts("");
+    bb_putchar('\n');
 
     if (!(id->field_valid & 1))
@@ -1150 +1228 @@
         printf(", LBAsects=%u", id->lba_capacity);
 
-    printf("\n IORDY=%s", (id->capability & 8) ? (id->capability & 4) ?  "on/off" : "yes" : "no");
+    printf("\n IORDY=%s",
+        (id->capability & 8)
+            ? ((id->capability & 4) ? "on/off" : "yes")
+            : "no");
 
     if (((id->capability & 8) || (id->field_valid & 2)) && (id->field_valid & 2))
@@ -1165 +1246 @@
     }
     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) {
@@ -1203 +1277 @@
         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);
         }
     }
@@ -1230 +1303 @@
      || (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");
-        if (id->major_rev_num != 0x0000 &&  /* NOVAL_0 */
-            id->major_rev_num != 0xFFFF) {  /* NOVAL_1 */
+        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++) {
                 if (id->major_rev_num & (1<<i))
-                        printf(" ATA/ATAPI-%u", i);
+                    printf(" ATA/ATAPI-%u", i);
             }
         }
@@ -1244 +1319 @@
 #endif
 
-static void flush_buffer_cache(int fd)
+static void flush_buffer_cache(/*int fd*/ void)
 {
     fsync(fd);              /* flush buffers */
@@ -1259 +1334 @@
 }
 
-static int seek_to_zero(int fd)
-{
-    if (lseek(fd, (off_t) 0, SEEK_SET))
-        return 1;
-    return 0;
-}
-
-static int read_big_block(int fd, char *buf)
+static void seek_to_zero(/*int fd*/ void)
+{
+    xlseek(fd, (off_t) 0, SEEK_SET);
+}
+
+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 int do_blkgetsize(int fd, unsigned long long *blksize64)
-{
-    int rc;
-    unsigned blksize32 = 0;
-
-    if (0 == ioctl(fd, BLKGETSIZE64, blksize64)) {  // returns bytes
-        *blksize64 /= 512;
-        return 0;
-    }
-    rc = ioctl_or_warn(fd, BLKGETSIZE, &blksize32); // returns sectors
-    *blksize64 = blksize32;
-    return rc;
-}
-
-static void print_timing(unsigned t, double e)
-{
-    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');
-}
-
-static void do_time(int flag, int fd)
-/* flag = 0 time_cache, 1 time_device */
-{
-    static const struct itimerval thousand = {{1000, 0}, {1000, 0}};
-
-    struct itimerval itv;
+}
+
+static unsigned dev_size_mb(/*int fd*/ void)
+{
+    union {
+        unsigned long long blksize64;
+        unsigned blksize32;
+    } u;
+
+    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);
+    }
+    if (u.blksize64 > UINT_MAX)
+        return UINT_MAX;
+    return u.blksize64;
+}
+
+static void print_timing(unsigned m, unsigned elapsed_us)
+{
+    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 cache /*,int fd*/)
+/* cache=1: time cache: repeatedly read N MB at offset 0
+ * cache=0: time device: linear read, starting at offset 0
+ */
+{
+    unsigned max_iterations, iterations;
+    unsigned start; /* doesn't need to be long long */
     unsigned elapsed, elapsed2;
-    unsigned max_iterations, total_MB, iterations;
-    unsigned long long blksize;
-    RESERVE_CONFIG_BUFFER(buf, TIMING_BUF_BYTES);
-
-    if (mlock(buf, TIMING_BUF_BYTES)) {
-        bb_perror_msg("mlock");
-        goto quit2;
-    }
-
-    max_iterations = 1024;
-    if (0 == do_blkgetsize(fd, &blksize)) {
-        max_iterations = blksize / (2 * 1024) / TIMING_BUF_MB;
-    }
-
-    /* Clear out the device request queues & give them time to complete */
+    unsigned total_MB;
+    char *buf = xmalloc(TIMING_BUF_BYTES);
+
+    if (mlock(buf, TIMING_BUF_BYTES))
+        bb_perror_msg_and_die("mlock");
+
+    /* 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 */
-        if (seek_to_zero(fd))
-            goto quit;
-        if (read_big_block(fd, buf))
-            goto quit;
-        printf(" Timing buffer-cache reads:  ");
+    sleep(1);
+    if (cache) { /* Time cache */
+        seek_to_zero();
+        read_big_block(buf);
+        printf("Timing buffer-cache reads: ");
     } else { /* Time device */
-        printf(" Timing buffered disk reads: ");
-    }
-    fflush(stdout);
+        printf("Timing buffered disk reads:");
+    }
+    fflush_all();
+
+    /* Now do the timing */
     iterations = 0;
-    /*
-     * getitimer() is used rather than gettimeofday() because
-     * it is much more consistent (on my machine, at least).
-     */
-    setitimer(ITIMER_REAL, &thousand, NULL);
-    /* Now do the timing */
+    /* 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 {
+        if (cache)
+            seek_to_zero();
+        read_big_block(buf);
+        elapsed = (unsigned)monotonic_us() - start;
         ++iterations;
-        if ((flag == 0) && seek_to_zero(fd))
-            goto quit;
-        if (read_big_block(fd, 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);
+    } 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 {
-            if (seek_to_zero(fd))
-                goto quit;
-            getitimer(ITIMER_REAL, &itv);
-            elapsed2 = (1000 - itv.it_value.tv_sec) * 1000000
-                    - itv.it_value.tv_usec;
+            seek_to_zero();
+            elapsed2 = (unsigned)monotonic_us() - start;
         } while (--iterations);
+        //printf(" elapsed2:%u ", elapsed2);
         elapsed -= elapsed2;
-        total_MB *= BUFCACHE_FACTOR;
-        flush_buffer_cache(fd);
-    }
-    print_timing(total_MB, elapsed / 1000000.0);
- quit:
+        total_MB *= 2; // BUFCACHE_FACTOR (why?)
+        flush_buffer_cache();
+    }
+    print_timing(total_MB, elapsed);
     munlock(buf, TIMING_BUF_BYTES);
- quit2:
-    RELEASE_CONFIG_BUFFER(buf);
+    free(buf);
 }
 
@@ -1391 +1463 @@
 
 #ifdef HDIO_DRIVE_CMD
-static void interpret_standby(unsigned standby)
-{
-    unsigned t;
-
+static void interpret_standby(uint8_t standby)
+{
     printf(" (");
-    if (standby == 0)
+    if (standby == 0) {
         printf("off");
-    else if (standby == 252)
-        printf("21 minutes");
-    else if (standby == 253)
+    } else if (standby <= 240 || standby == 252 || standby == 255) {
+        /* standby is in 5 sec units */
+        unsigned t = standby * 5;
+        printf("%u minutes %u seconds", t / 60, t % 60);
+    } else if (standby <= 251) {
+        unsigned t = (standby - 240); /* t is in 30 min units */;
+        printf("%u.%c hours", t / 2, (t & 1) ? '5' : '0');
+    }
+    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 <= 251) {
-        t = (standby - 240) * 30;
-        printf("%u hours + %u minutes", t / 60, t % 60);
-    } else
-        printf("illegal value");
+    if (standby == 254)
+        printf("reserved");
     printf(")\n");
 }
@@ -1433 +1499 @@
 static int translate_xfermode(const char *name)
 {
-    int val, i;
+    int val;
+    unsigned i;
 
     for (i = 0; i < ARRAY_SIZE(xfermode_val); i++) {
@@ -1463 +1530 @@
         printf("UltraDMA mode%u", xfermode - 64);
     else
-        printf("Unknown");
+        printf("unknown");
     printf(")\n");
 }
@@ -1476 +1543 @@
 static void process_dev(char *devname)
 {
-    int fd;
+    /*int fd;*/
     long parm, multcount;
 #ifndef HDIO_DRIVE_CMD
@@ -1486 +1553 @@
     const char *fmt = " %s\t= %2ld";
 
-    fd = xopen(devname, O_RDONLY|O_NONBLOCK);
+    /*fd = xopen_nonblocking(devname);*/
+    xmove_fd(xopen_nonblocking(devname), fd);
     printf("\n%s:\n", devname);
 
-    if (set_readahead) {
-        print_flag(get_readahead, "fs readahead", Xreadahead);
+    if (getset_readahead == IS_SET) {
+        print_flag(getset_readahead, "fs readahead", Xreadahead);
         ioctl_or_warn(fd, BLKRASET, (int *)Xreadahead);
     }
@@ -1500 +1568 @@
 #endif
 #if ENABLE_FEATURE_HDPARM_HDIO_SCAN_HWIF
-    if (scan_hwif) {
+    if (scan_hwif == IS_SET) {
         printf(" attempting to scan hwif (0x%lx, 0x%lx, %lu)\n", hwif_data, hwif_ctrl, hwif_irq);
         args[0] = hwif_data;
@@ -1524 +1592 @@
         ioctl_or_warn(fd, HDIO_SET_PIO_MODE, (int *)(unsigned long)piomode);
     }
-    if (set_io32bit) {
-        print_flag(get_io32bit, "32-bit IO_support flag", io32bit);
+    if (getset_io32bit == IS_SET) {
+        print_flag(getset_io32bit, "32-bit IO_support flag", io32bit);
         ioctl_or_warn(fd, HDIO_SET_32BIT, (int *)io32bit);
     }
-    if (set_mult) {
-        print_flag(get_mult, "multcount", mult);
+    if (getset_mult == IS_SET) {
+        print_flag(getset_mult, "multcount", mult);
 #ifdef HDIO_DRIVE_CMD
         ioctl_or_warn(fd, HDIO_SET_MULTCOUNT, (void *)mult);
@@ -1536 +1604 @@
 #endif
     }
-    if (set_readonly) {
-        print_flag_on_off(get_readonly, "readonly", readonly);
+    if (getset_readonly == IS_SET) {
+        print_flag_on_off(getset_readonly, "readonly", readonly);
         ioctl_or_warn(fd, BLKROSET, &readonly);
     }
-    if (set_unmask) {
-        print_flag_on_off(get_unmask, "unmaskirq", unmask);
+    if (getset_unmask == IS_SET) {
+        print_flag_on_off(getset_unmask, "unmaskirq", unmask);
         ioctl_or_warn(fd, HDIO_SET_UNMASKINTR, (int *)unmask);
     }
 #if ENABLE_FEATURE_HDPARM_HDIO_GETSET_DMA
-    if (set_dma) {
-        print_flag_on_off(get_dma, "using_dma", dma);
+    if (getset_dma == IS_SET) {
+        print_flag_on_off(getset_dma, "using_dma", dma);
         ioctl_or_warn(fd, HDIO_SET_DMA, (int *)dma);
     }
 #endif /* FEATURE_HDPARM_HDIO_GETSET_DMA */
-    if (set_dma_q) {
-        print_flag_on_off(get_dma_q, "DMA queue_depth", dma_q);
+#ifdef HDIO_SET_QDMA
+    if (getset_dma_q == IS_SET) {
+        print_flag_on_off(getset_dma_q, "DMA queue_depth", dma_q);
         ioctl_or_warn(fd, HDIO_SET_QDMA, (int *)dma_q);
     }
-    if (set_nowerr) {
-        print_flag_on_off(get_nowerr, "nowerr", nowerr);
+#endif
+    if (getset_nowerr == IS_SET) {
+        print_flag_on_off(getset_nowerr, "nowerr", nowerr);
         ioctl_or_warn(fd, HDIO_SET_NOWERR, (int *)nowerr);
     }
-    if (set_keep) {
-        print_flag_on_off(get_keep, "keep_settings", keep);
+    if (getset_keep == IS_SET) {
+        print_flag_on_off(getset_keep, "keep_settings", keep);
         ioctl_or_warn(fd, HDIO_SET_KEEPSETTINGS, (int *)keep);
     }
 #ifdef HDIO_DRIVE_CMD
-    if (set_doorlock) {
+    if (getset_doorlock == IS_SET) {
         args[0] = doorlock ? WIN_DOORLOCK : WIN_DOORUNLOCK;
         args[2] = 0;
-        print_flag_on_off(get_doorlock, "drive doorlock", doorlock);
+        print_flag_on_off(getset_doorlock, "drive doorlock", doorlock);
         ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args);
         args[0] = WIN_SETFEATURES;
     }
-    if (set_dkeep) {
+    if (getset_dkeep == IS_SET) {
         /* lock/unlock the drive's "feature" settings */
-        print_flag_on_off(get_dkeep, "drive keep features", dkeep);
+        print_flag_on_off(getset_dkeep, "drive keep features", dkeep);
         args[2] = dkeep ? 0x66 : 0xcc;
         ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args);
     }
-    if (set_defects) {
+    if (getset_defects == IS_SET) {
         args[2] = defects ? 0x04 : 0x84;
-        print_flag(get_defects, "drive defect-mgmt", defects);
+        print_flag(getset_defects, "drive defect-mgmt", defects);
         ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args);
     }
-    if (set_prefetch) {
+    if (getset_prefetch == IS_SET) {
         args[1] = prefetch;
         args[2] = 0xab;
-        print_flag(get_prefetch, "drive prefetch", prefetch);
+        print_flag(getset_prefetch, "drive prefetch", prefetch);
         ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args);
         args[1] = 0;
@@ -1591 +1661 @@
         args[1] = xfermode_requested;
         args[2] = 3;
-        if (get_xfermode) {
-            print_flag(1, "xfermode", xfermode_requested);
-            interpret_xfermode(xfermode_requested);
-        }
+        print_flag(1, "xfermode", xfermode_requested);
+        interpret_xfermode(xfermode_requested);
         ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args);
         args[1] = 0;
     }
-    if (set_lookahead) {
+    if (getset_lookahead == IS_SET) {
         args[2] = lookahead ? 0xaa : 0x55;
-        print_flag_on_off(get_lookahead, "drive read-lookahead", lookahead);
+        print_flag_on_off(getset_lookahead, "drive read-lookahead", lookahead);
         ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args);
     }
-    if (set_apmmode) {
-        args[2] = (apmmode == 255) ? 0x85 /* disable */ : 0x05 /* set */; /* feature register */
+    if (getset_apmmode == IS_SET) {
+        /* feature register */
+        args[2] = (apmmode == 255) ? 0x85 /* disable */ : 0x05 /* set */;
         args[1] = apmmode; /* sector count register 1-255 */
-        if (get_apmmode)
-            printf(" setting APM level to %s 0x%02lX (%ld)\n", (apmmode == 255) ? "disabled" : "", apmmode, apmmode);
+        printf(" setting APM level to %s 0x%02lX (%ld)\n",
+            (apmmode == 255) ? "disabled" : "",
+            apmmode, apmmode);
         ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args);
         args[1] = 0;
     }
-    if (set_wcache) {
+    if (getset_wcache == IS_SET) {
 #ifdef DO_FLUSHCACHE
 #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);
+        print_flag_on_off(getset_wcache, "drive write-caching", wcache);
 #ifdef DO_FLUSHCACHE
         if (!wcache)
@@ -1642 +1711 @@
 #define WIN_STANDBYNOW2 0x94
 #endif
-        if (get_standbynow) printf(" issuing standby command\n");
+        printf(" issuing standby command\n");
         args[0] = WIN_STANDBYNOW1;
-        ioctl_alt_or_warn(fd, HDIO_DRIVE_CMD, args, WIN_STANDBYNOW2);
+        ioctl_alt_or_warn(HDIO_DRIVE_CMD, args, WIN_STANDBYNOW2);
     }
     if (set_sleepnow) {
@@ -1653 +1722 @@
 #define WIN_SLEEPNOW2 0x99
 #endif
-        if (get_sleepnow) printf(" issuing sleep command\n");
+        printf(" issuing sleep command\n");
         args[0] = WIN_SLEEPNOW1;
-        ioctl_alt_or_warn(fd, HDIO_DRIVE_CMD, args, WIN_SLEEPNOW2);
+        ioctl_alt_or_warn(HDIO_DRIVE_CMD, args, WIN_SLEEPNOW2);
     }
     if (set_seagate) {
         args[0] = 0xfb;
-        if (get_seagate) printf(" disabling Seagate auto powersaving mode\n");
+        printf(" disabling Seagate auto powersaving mode\n");
         ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args);
     }
-    if (set_standby) {
+    if (getset_standby == IS_SET) {
         args[0] = WIN_SETIDLE1;
         args[1] = standby_requested;
-        if (get_standby) {
-            print_flag(1, "standby", standby_requested);
-            interpret_standby(standby_requested);
-        }
+        print_flag(1, "standby", standby_requested);
+        interpret_standby(standby_requested);
         ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args);
         args[1] = 0;
@@ -1675 +1742 @@
     if (force_operation) {
         char buf[512];
-        flush_buffer_cache(fd);
+        flush_buffer_cache();
         if (-1 == read(fd, buf, sizeof(buf)))
-            bb_perror_msg("read(%d bytes) failed (rc=%d)", sizeof(buf), -1);
-    }
-#endif  /* HDIO_DRIVE_CMD */
-
-    if (get_mult || get_identity) {
+            bb_perror_msg("read of 512 bytes failed");
+    }
+#endif  /* HDIO_DRIVE_CMD */
+    if (getset_mult || get_identity) {
         multcount = -1;
         if (ioctl(fd, HDIO_GET_MULTCOUNT, &multcount)) {
-            if (get_mult && ENABLE_IOCTL_HEX2STR_ERROR) /* To be coherent with ioctl_or_warn. */
+            /* To be coherent with ioctl_or_warn. */
+            if (getset_mult && ENABLE_IOCTL_HEX2STR_ERROR)
                 bb_perror_msg("HDIO_GET_MULTCOUNT");
             else
                 bb_perror_msg("ioctl %#x failed", HDIO_GET_MULTCOUNT);
-        } else if (get_mult) {
+        } else if (getset_mult) {
             printf(fmt, "multcount", multcount);
             on_off(multcount != 0);
         }
     }
-    if (get_io32bit) {
+    if (getset_io32bit) {
         if (!ioctl_or_warn(fd, HDIO_GET_32BIT, &parm)) {
             printf(" IO_support\t=%3ld (", parm);
@@ -1710 +1777 @@
         }
     }
-    if (get_unmask) {
-        if(!ioctl_or_warn(fd, HDIO_GET_UNMASKINTR, (unsigned long *)parm))
+    if (getset_unmask) {
+        if (!ioctl_or_warn(fd, HDIO_GET_UNMASKINTR, &parm))
             print_value_on_off("unmaskirq", parm);
     }
-
-
 #if ENABLE_FEATURE_HDPARM_HDIO_GETSET_DMA
-    if (get_dma) {
+    if (getset_dma) {
         if (!ioctl_or_warn(fd, HDIO_GET_DMA, &parm)) {
             printf(fmt, "using_dma", parm);
@@ -1727 +1792 @@
     }
 #endif
-    if (get_dma_q) {
-        if(!ioctl_or_warn(fd, HDIO_GET_QDMA, (unsigned long *)parm))
+#ifdef HDIO_GET_QDMA
+    if (getset_dma_q) {
+        if (!ioctl_or_warn(fd, HDIO_GET_QDMA, &parm))
             print_value_on_off("queue_depth", parm);
     }
-    if (get_keep) {
-        if(!ioctl_or_warn(fd, HDIO_GET_KEEPSETTINGS, (unsigned long *)parm))
+#endif
+    if (getset_keep) {
+        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 (getset_nowerr) {
+        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 (getset_readonly) {
+        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 (getset_readahead) {
+        if (!ioctl_or_warn(fd, BLKRAGET, &parm))
             print_value_on_off("readahead", parm);
     }
@@ -1754 +1820 @@
             if (!ioctl_or_warn(fd, HDIO_GETGEO, &g))
                 printf(" geometry\t= %u/%u/%u, sectors = %ld, start = %ld\n",
-                        g.cylinders, g.heads, g.sectors, parm, g.start);
+                    g.cylinders, g.heads, g.sectors, parm, g.start);
         }
     }
@@ -1768 +1834 @@
 
         args[0] = WIN_CHECKPOWERMODE1;
-        if (ioctl_alt_or_warn(fd, HDIO_DRIVE_CMD, args, WIN_CHECKPOWERMODE2)) {
+        if (ioctl_alt_or_warn(HDIO_DRIVE_CMD, args, WIN_CHECKPOWERMODE2)) {
             if (errno != EIO || args[0] != 0 || args[1] != 0)
                 state = "unknown";
@@ -1817 +1883 @@
         args1[0] = WIN_IDENTIFY;
         args1[3] = 1;
-        if (!ioctl_alt_or_warn(fd, HDIO_DRIVE_CMD, args1, WIN_PIDENTIFY))
+        if (!ioctl_alt_or_warn(HDIO_DRIVE_CMD, args1, WIN_PIDENTIFY))
             identify((void *)(args1 + 4));
     }
 #endif
 #if ENABLE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF
-    if (set_busstate) {
-        if (get_busstate) {
-            print_flag(1, "bus state", busstate);
-            bus_state_value(busstate);
-        }
+    if (getset_busstate == IS_SET) {
+        print_flag(1, "bus state", busstate);
+        bus_state_value(busstate);
         ioctl_or_warn(fd, HDIO_SET_BUSSTATE, (int *)(unsigned long)busstate);
     }
-    if (get_busstate) {
+    if (getset_busstate) {
         if (!ioctl_or_warn(fd, HDIO_GET_BUSSTATE, &parm)) {
             printf(fmt, "bus state", parm);
@@ -1840 +1904 @@
 
     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(fd);
+        flush_buffer_cache();
     close(fd);
 }
@@ -1858 +1922 @@
 }
 
+static void identify_from_stdin(void) NORETURN;
 static void identify_from_stdin(void)
 {
@@ -1865 +1930 @@
     int i;
 
-    xread(0, buf, 1280);
+    xread(STDIN_FILENO, buf, 1280);
 
     // Convert the newline-separated hex data into an identify block.
@@ -1879 +1944 @@
     identify(sbuf);
 }
+#else
+void identify_from_stdin(void);
 #endif
 
 /* busybox specific stuff */
-static void parse_opts(smallint *get, smallint *set, unsigned long *value, int min, int max)
-{
-    if (get) {
-        *get = 1;
-    }
+static int parse_opts(unsigned long *value, int min, int max)
+{
     if (optarg) {
-        *set = 1;
         *value = xatol_range(optarg, min, max);
-    }
+        return IS_SET;
+    }
+    return IS_GET;
+}
+static int parse_opts_0_max(unsigned long *value, int max)
+{
+    return parse_opts(value, 0, max);
+}
+static int parse_opts_0_1(unsigned long *value)
+{
+    return parse_opts(value, 0, 1);
+}
+static int parse_opts_0_INTMAX(unsigned long *value)
+{
+    return parse_opts(value, 0, INT_MAX);
 }
 
@@ -1896 +1973 @@
 {
     if (flag) {
-        *get = 1;
+        *get = IS_GET;
         if (optarg) {
             *value = translate_xfermode(optarg);
@@ -1906 +1983 @@
 /*------- getopt short options --------*/
 static const char hdparm_options[] ALIGN1 =
-    "gfu::n::p:r::m::c::k::a::B:tTh"
-    USE_FEATURE_HDPARM_GET_IDENTITY("iI")
-    USE_FEATURE_HDPARM_HDIO_GETSET_DMA("d::")
+    "gfu::n::p:r::m::c::k::a::B:tT"
+    IF_FEATURE_HDPARM_GET_IDENTITY("iI")
+    IF_FEATURE_HDPARM_HDIO_GETSET_DMA("d::")
 #ifdef HDIO_DRIVE_CMD
     "S:D:P:X:K:A:L:W:CyYzZ"
 #endif
-    USE_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF("U:")
+    IF_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF("U:")
 #ifdef HDIO_GET_QDMA
 #ifdef HDIO_SET_QDMA
@@ -1920 +1997 @@
 #endif
 #endif
-    USE_FEATURE_HDPARM_HDIO_DRIVE_RESET("w")
-    USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF("x::b:")
-    USE_FEATURE_HDPARM_HDIO_SCAN_HWIF("R:");
+    IF_FEATURE_HDPARM_HDIO_DRIVE_RESET("w")
+    IF_FEATURE_HDPARM_HDIO_TRISTATE_HWIF("x::b:")
+    IF_FEATURE_HDPARM_HDIO_SCAN_HWIF("R:");
 /*-------------------------------------*/
 
 /* 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)
 {
@@ -1934 +2011 @@
     while ((c = getopt(argc, argv, hdparm_options)) >= 0) {
         flagcount++;
-        if (c == 'h') bb_show_usage(); /* EXIT */
-        USE_FEATURE_HDPARM_GET_IDENTITY(get_IDentity |= (c == 'I'));
-        USE_FEATURE_HDPARM_GET_IDENTITY(get_identity |= (c == 'i'));
+        IF_FEATURE_HDPARM_GET_IDENTITY(get_IDentity |= (c == 'I'));
+        IF_FEATURE_HDPARM_GET_IDENTITY(get_identity |= (c == 'i'));
         get_geom |= (c == 'g');
         do_flush |= (c == 'f');
-        if (c == 'u') parse_opts(&get_unmask, &set_unmask, &unmask, 0, 1);
-        USE_FEATURE_HDPARM_HDIO_GETSET_DMA(if (c == 'd') parse_opts(&get_dma, &set_dma, &dma, 0, 9));
-        if (c == 'n') parse_opts(&get_nowerr, &set_nowerr, &nowerr, 0, 1);
+        if (c == 'u') getset_unmask    = parse_opts_0_1(&unmask);
+    IF_FEATURE_HDPARM_HDIO_GETSET_DMA(
+        if (c == 'd') getset_dma       = parse_opts_0_max(&dma, 9);
+    )
+        if (c == 'n') getset_nowerr    = parse_opts_0_1(&nowerr);
         parse_xfermode((c == 'p'), &noisy_piomode, &set_piomode, &piomode);
-        if (c == 'r') parse_opts(&get_readonly, &set_readonly, &readonly, 0, 1);
-        if (c == 'm') parse_opts(&get_mult, &set_mult, &mult, 0, INT_MAX /*32*/);
-        if (c == 'c') parse_opts(&get_io32bit, &set_io32bit, &io32bit, 0, INT_MAX /*8*/);
-        if (c == 'k') parse_opts(&get_keep, &set_keep, &keep, 0, 1);
-        if (c == 'a') parse_opts(&get_readahead, &set_readahead, &Xreadahead, 0, INT_MAX);
-        if (c == 'B') parse_opts(&get_apmmode, &set_apmmode, &apmmode, 1, 255);
+        if (c == 'r') getset_readonly  = parse_opts_0_1(&readonly);
+        if (c == 'm') getset_mult      = parse_opts_0_INTMAX(&mult /*32*/);
+        if (c == 'c') getset_io32bit   = parse_opts_0_INTMAX(&io32bit /*8*/);
+        if (c == 'k') getset_keep      = parse_opts_0_1(&keep);
+        if (c == 'a') getset_readahead = parse_opts_0_INTMAX(&Xreadahead);
+        if (c == 'B') getset_apmmode   = parse_opts(&apmmode, 1, 255);
         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 == 'D') parse_opts(&get_defects, &set_defects, &defects, 0, INT_MAX);
-        if (c == 'P') parse_opts(&get_prefetch, &set_prefetch, &prefetch, 0, INT_MAX);
+        if (c == 'S') getset_standby  = parse_opts_0_max(&standby_requested, 255);
+        if (c == 'D') getset_defects  = parse_opts_0_INTMAX(&defects);
+        if (c == 'P') getset_prefetch = parse_opts_0_INTMAX(&prefetch);
         parse_xfermode((c == 'X'), &get_xfermode, &set_xfermode, &xfermode_requested);
-        if (c == 'K') parse_opts(&get_dkeep, &set_dkeep, &prefetch, 0, 1);
-        if (c == 'A') parse_opts(&get_lookahead, &set_lookahead, &lookahead, 0, 1);
-        if (c == 'L') parse_opts(&get_doorlock, &set_doorlock, &doorlock, 0, 1);
-        if (c == 'W') parse_opts(&get_wcache, &set_wcache, &wcache, 0, 1);
+        if (c == 'K') getset_dkeep     = parse_opts_0_1(&prefetch);
+        if (c == 'A') getset_lookahead = parse_opts_0_1(&lookahead);
+        if (c == 'L') getset_doorlock  = parse_opts_0_1(&doorlock);
+        if (c == 'W') getset_wcache    = parse_opts_0_1(&wcache);
         get_powermode |= (c == 'C');
-        get_standbynow = set_standbynow |= (c == 'y');
-        get_sleepnow = set_sleepnow |= (c == 'Y');
+        set_standbynow |= (c == 'y');
+        set_sleepnow |= (c == 'Y');
         reread_partn |= (c == 'z');
-        get_seagate = set_seagate |= (c == 'Z');
-#endif
-        USE_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF(if (c == 'U') parse_opts(NULL, &unregister_hwif, &hwif, 0, INT_MAX));
+        set_seagate |= (c == 'Z');
+#endif
+        IF_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF(if (c == 'U') unregister_hwif = parse_opts_0_INTMAX(&hwif));
 #ifdef HDIO_GET_QDMA
         if (c == 'Q') {
-#ifdef HDIO_SET_QDMA
-            parse_opts(&get_dma_q, &set_dma_q, &dma_q, 0, INT_MAX);
-#else
-            parse_opts(&get_dma_q, NULL, NULL, 0, 0);
-#endif
-        }
-#endif
-        USE_FEATURE_HDPARM_HDIO_DRIVE_RESET(perform_reset = (c == 'r'));
-        USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(if (c == 'x') parse_opts(NULL, &perform_tristate, &tristate, 0, 1));
-        USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(if (c == 'b') parse_opts(&get_busstate, &set_busstate, &busstate, 0, 2));
+            getset_dma_q = parse_opts_0_INTMAX(&dma_q);
+        }
+#endif
+        IF_FEATURE_HDPARM_HDIO_DRIVE_RESET(perform_reset = (c == 'r'));
+        IF_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(if (c == 'x') perform_tristate = parse_opts_0_1(&tristate));
+        IF_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(if (c == 'b') getset_busstate = parse_opts_0_max(&busstate, 2));
 #if ENABLE_FEATURE_HDPARM_HDIO_SCAN_HWIF
         if (c == 'R') {
-            parse_opts(NULL, &scan_hwif, &hwif_data, 0, INT_MAX);
-            hwif_ctrl = xatoi_u((argv[optind]) ? argv[optind] : "");
-            hwif_irq  = xatoi_u((argv[optind+1]) ? argv[optind+1] : "");
+            scan_hwif = parse_opts_0_INTMAX(&hwif_data);
+            hwif_ctrl = xatoi_positive((argv[optind]) ? argv[optind] : "");
+            hwif_irq  = xatoi_positive((argv[optind+1]) ? argv[optind+1] : "");
             /* Move past the 2 additional arguments */
             argv += 2;
@@ -1992 +2066 @@
     /* When no flags are given (flagcount = 0), -acdgkmnru is assumed. */
     if (!flagcount) {
-        get_mult = get_io32bit = get_unmask = get_keep = get_readonly = get_readahead = get_geom = 1;
-        USE_FEATURE_HDPARM_HDIO_GETSET_DMA(get_dma = 1);
+        getset_mult = getset_io32bit = getset_unmask = getset_keep = getset_readonly = getset_readahead = get_geom = IS_GET;
+        IF_FEATURE_HDPARM_HDIO_GETSET_DMA(getset_dma = IS_GET);
     }
     argv += optind;
@@ -2000 +2074 @@
         if (ENABLE_FEATURE_HDPARM_GET_IDENTITY && !isatty(STDIN_FILENO))
             identify_from_stdin(); /* EXIT */
-        else bb_show_usage();
+        bb_show_usage();
     }