miscutils/hdparm.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * hdparm implementation for busybox
   4  *
   5  *
   6  * Copyright (C) [2003] by [Matteo Croce] <3297627799@wind.it>
   7  *
   8  * Hacked by Tito <farmatito@tiscali.it> for size optimization.
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  18  * General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  23  * 02111-1307 USA
  24  *
  25  *
  26  * This program is based on the source code of hdparm: see below...
  27  * hdparm.c - Command line interface to get/set hard disk parameters
  28  *          - by Mark Lord (C) 1994-2002 -- freely distributable
  29  */
  30
  31 #include <unistd.h>
  32 #include <string.h>
  33 #include <stdlib.h>
  34 #include <fcntl.h>
  35 #include <errno.h>
  36 #include <ctype.h>
  37 #include <endian.h>
  38 #include <sys/ioctl.h>
  39 #include <sys/shm.h>
  40 #include <sys/sysmacros.h>
  41 #include <sys/time.h>
  42 #include <sys/times.h>
  43 #include <sys/mount.h>
  44 #include "busybox.h"
  45 #include <linux/types.h>
  46 #include <linux/hdreg.h>
  47 #include <linux/major.h>
  48 #include <asm/byteorder.h>
  49
  50
  51 #if (__BYTE_ORDER == __BIG_ENDIAN) && !defined(__USE_XOPEN)
  52 #define __USE_XOPEN
  53 #endif
  54
  55 /* device types */
  56 /* ------------ */
  57 #define NO_DEV                  0xffff
  58 #define ATA_DEV                 0x0000
  59 #define ATAPI_DEV               0x0001
  60
  61 /* word definitions */
  62 /* ---------------- */
  63 #define GEN_CONFIG              0   /* general configuration */
  64 #define LCYLS                   1   /* number of logical cylinders */
  65 #define CONFIG                  2   /* specific configuration */
  66 #define LHEADS                  3   /* number of logical heads */
  67 #define TRACK_BYTES             4   /* number of bytes/track (ATA-1) */
  68 #define SECT_BYTES              5   /* number of bytes/sector (ATA-1) */
  69 #define LSECTS                  6   /* number of logical sectors/track */
  70 #define START_SERIAL            10  /* ASCII serial number */
  71 #define LENGTH_SERIAL           10  /* 10 words (20 bytes or characters) */
  72 #define BUF_TYPE                20  /* buffer type (ATA-1) */
  73 #define BUFFER__SIZE            21  /* buffer size (ATA-1) */
  74 #define RW_LONG                 22  /* extra bytes in R/W LONG cmd ( < ATA-4)*/
  75 #define START_FW_REV            23  /* ASCII firmware revision */
  76 #define LENGTH_FW_REV            4  /*  4 words (8 bytes or characters) */
  77 #define START_MODEL             27  /* ASCII model number */
  78 #define LENGTH_MODEL            20  /* 20 words (40 bytes or characters) */
  79 #define SECTOR_XFER_MAX         47  /* r/w multiple: max sectors xfered */
  80 #define DWORD_IO                48  /* can do double-word IO (ATA-1 only) */
  81 #define CAPAB_0                 49  /* capabilities */
  82 #define CAPAB_1                 50
  83 #define PIO_MODE                51  /* max PIO mode supported (obsolete)*/
  84 #define DMA_MODE                52  /* max Singleword DMA mode supported (obs)*/
  85 #define WHATS_VALID             53  /* what fields are valid */
  86 #define LCYLS_CUR               54  /* current logical cylinders */
  87 #define LHEADS_CUR              55  /* current logical heads */
  88 #define LSECTS_CUR              56  /* current logical sectors/track */
  89 #define CAPACITY_LSB            57  /* current capacity in sectors */
  90 #define CAPACITY_MSB            58
  91 #define SECTOR_XFER_CUR         59  /* r/w multiple: current sectors xfered */
  92 #define LBA_SECTS_LSB           60  /* LBA: total number of user */
  93 #define LBA_SECTS_MSB           61  /*      addressable sectors */
  94 #define SINGLE_DMA              62  /* singleword DMA modes */
  95 #define MULTI_DMA               63  /* multiword DMA modes */
  96 #define ADV_PIO_MODES           64  /* advanced PIO modes supported */
  97                                     /* multiword DMA xfer cycle time: */
  98 #define DMA_TIME_MIN            65  /*   - minimum */
  99 #define DMA_TIME_NORM           66  /*   - manufacturer's recommended   */
 100                                     /* minimum PIO xfer cycle time: */
 101 #define PIO_NO_FLOW             67  /*   - without flow control */
 102 #define PIO_FLOW                68  /*   - with IORDY flow control */
 103 #define PKT_REL                 71  /* typical #ns from PKT cmd to bus rel */
 104 #define SVC_NBSY                72  /* typical #ns from SERVICE cmd to !BSY */
 105 #define CDR_MAJOR               73  /* CD ROM: major version number */
 106 #define CDR_MINOR               74  /* CD ROM: minor version number */
 107 #define QUEUE_DEPTH             75  /* queue depth */
 108 #define MAJOR                   80  /* major version number */
 109 #define MINOR                   81  /* minor version number */
 110 #define CMDS_SUPP_0             82  /* command/feature set(s) supported */
 111 #define CMDS_SUPP_1             83
 112 #define CMDS_SUPP_2             84
 113 #define CMDS_EN_0               85  /* command/feature set(s) enabled */
 114 #define CMDS_EN_1               86
 115 #define CMDS_EN_2               87
 116 #define ULTRA_DMA               88  /* ultra DMA modes */
 117                                     /* time to complete security erase */
 118 #define ERASE_TIME              89  /*   - ordinary */
 119 #define ENH_ERASE_TIME          90  /*   - enhanced */
 120 #define ADV_PWR                 91  /* current advanced power management level
 121                                        in low byte, 0x40 in high byte. */
 122 #define PSWD_CODE               92  /* master password revision code    */
 123 #define HWRST_RSLT              93  /* hardware reset result */
 124 #define ACOUSTIC                94  /* acoustic mgmt values ( >= ATA-6) */
 125 #define LBA_LSB                 100 /* LBA: maximum.  Currently only 48 */
 126 #define LBA_MID                 101 /*      bits are used, but addr 103 */
 127 #define LBA_48_MSB              102 /*      has been reserved for LBA in */
 128 #define LBA_64_MSB              103 /*      the future. */
 129 #define RM_STAT                 127 /* removable media status notification feature set support */
 130 #define SECU_STATUS             128 /* security status */
 131 #define CFA_PWR_MODE            160 /* CFA power mode 1 */
 132 #define START_MEDIA             176 /* media serial number */
 133 #define LENGTH_MEDIA            20  /* 20 words (40 bytes or characters)*/
 134 #define START_MANUF             196 /* media manufacturer I.D. */
 135 #define LENGTH_MANUF            10  /* 10 words (20 bytes or characters) */
 136 #define INTEGRITY               255 /* integrity word */
 137
 138 /* bit definitions within the words */
 139 /* -------------------------------- */
 140
 141 /* many words are considered valid if bit 15 is 0 and bit 14 is 1 */
 142 #define VALID                   0xc000
 143 #define VALID_VAL               0x4000
 144 /* many words are considered invalid if they are either all-0 or all-1 */
 145 #define NOVAL_0                 0x0000
 146 #define NOVAL_1                 0xffff
 147
 148 /* word 0: gen_config */
 149 #define NOT_ATA                 0x8000
 150 #define NOT_ATAPI               0x4000  /* (check only if bit 15 == 1) */
 151 #define MEDIA_REMOVABLE         0x0080
 152 #define DRIVE_NOT_REMOVABLE     0x0040  /* bit obsoleted in ATA 6 */
 153 #define INCOMPLETE              0x0004
 154 #define CFA_SUPPORT_VAL         0x848a  /* 848a=CFA feature set support */
 155 #define DRQ_RESPONSE_TIME       0x0060
 156 #define DRQ_3MS_VAL             0x0000
 157 #define DRQ_INTR_VAL            0x0020
 158 #define DRQ_50US_VAL            0x0040
 159 #define PKT_SIZE_SUPPORTED      0x0003
 160 #define PKT_SIZE_12_VAL         0x0000
 161 #define PKT_SIZE_16_VAL         0x0001
 162 #define EQPT_TYPE               0x1f00
 163 #define SHIFT_EQPT              8
 164
 165 #define CDROM 0x0005
 166
 167 #ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY
 168 static const char * const pkt_str[] = {
 169         "Direct-access device",                 /* word 0, bits 12-8 = 00 */
 170         "Sequential-access device",             /* word 0, bits 12-8 = 01 */
 171         "Printer",                              /* word 0, bits 12-8 = 02 */
 172         "Processor",                            /* word 0, bits 12-8 = 03 */
 173         "Write-once device",                    /* word 0, bits 12-8 = 04 */
 174         "CD-ROM",                               /* word 0, bits 12-8 = 05 */
 175         "Scanner",                              /* word 0, bits 12-8 = 06 */
 176         "Optical memory",                       /* word 0, bits 12-8 = 07 */
 177         "Medium changer",                       /* word 0, bits 12-8 = 08 */
 178         "Communications device",                /* word 0, bits 12-8 = 09 */
 179         "ACS-IT8 device",                       /* word 0, bits 12-8 = 0a */
 180         "ACS-IT8 device",                       /* word 0, bits 12-8 = 0b */
 181         "Array controller",                     /* word 0, bits 12-8 = 0c */
 182         "Enclosure services",                   /* word 0, bits 12-8 = 0d */
 183         "Reduced block command device",         /* word 0, bits 12-8 = 0e */
 184         "Optical card reader/writer",           /* word 0, bits 12-8 = 0f */
 185         "",                                     /* word 0, bits 12-8 = 10 */
 186         "",                                     /* word 0, bits 12-8 = 11 */
 187         "",                                     /* word 0, bits 12-8 = 12 */
 188         "",                                     /* word 0, bits 12-8 = 13 */
 189         "",                                     /* word 0, bits 12-8 = 14 */
 190         "",                                     /* word 0, bits 12-8 = 15 */
 191         "",                                     /* word 0, bits 12-8 = 16 */
 192         "",                                     /* word 0, bits 12-8 = 17 */
 193         "",                                     /* word 0, bits 12-8 = 18 */
 194         "",                                     /* word 0, bits 12-8 = 19 */
 195         "",                                     /* word 0, bits 12-8 = 1a */
 196         "",                                     /* word 0, bits 12-8 = 1b */
 197         "",                                     /* word 0, bits 12-8 = 1c */
 198         "",                                     /* word 0, bits 12-8 = 1d */
 199         "",                                     /* word 0, bits 12-8 = 1e */
 200         "Unknown",                              /* word 0, bits 12-8 = 1f */
 201 };
 202
 203 static const char * const ata1_cfg_str[] = {                    /* word 0 in ATA-1 mode */
 204         "reserved",                             /* bit 0 */
 205         "hard sectored",                        /* bit 1 */
 206         "soft sectored",                        /* bit 2 */
 207         "not MFM encoded ",                     /* bit 3 */
 208         "head switch time > 15us",              /* bit 4 */
 209         "spindle motor control option",         /* bit 5 */
 210         "fixed drive",                          /* bit 6 */
 211         "removable drive",                      /* bit 7 */
 212         "disk xfer rate <= 5Mbs",               /* bit 8 */
 213         "disk xfer rate > 5Mbs, <= 10Mbs",      /* bit 9 */
 214         "disk xfer rate > 5Mbs",                /* bit 10 */
 215         "rotational speed tol.",                /* bit 11 */
 216         "data strobe offset option",            /* bit 12 */
 217         "track offset option",                  /* bit 13 */
 218         "format speed tolerance gap reqd",      /* bit 14 */
 219         "ATAPI"                                 /* bit 14 */
 220 };
 221 #endif
 222
 223 /* word 1: number of logical cylinders */
 224 #define LCYLS_MAX               0x3fff /* maximum allowable value */
 225
 226 /* word 2: specific configuration
 227  * (a) require SET FEATURES to spin-up
 228  * (b) require spin-up to fully reply to IDENTIFY DEVICE
 229  */
 230 #define STBY_NID_VAL            0x37c8  /*     (a) and     (b) */
 231 #define STBY_ID_VAL             0x738c  /*     (a) and not (b) */
 232 #define PWRD_NID_VAL            0x8c73  /* not (a) and     (b) */
 233 #define PWRD_ID_VAL             0xc837  /* not (a) and not (b) */
 234
 235 /* words 47 & 59: sector_xfer_max & sector_xfer_cur */
 236 #define SECTOR_XFER             0x00ff  /* sectors xfered on r/w multiple cmds*/
 237 #define MULTIPLE_SETTING_VALID  0x0100  /* 1=multiple sector setting is valid */
 238
 239 /* word 49: capabilities 0 */
 240 #define STD_STBY                0x2000  /* 1=standard values supported (ATA);
 241                                            0=vendor specific values */
 242 #define IORDY_SUP               0x0800  /* 1=support; 0=may be supported */
 243 #define IORDY_OFF               0x0400  /* 1=may be disabled */
 244 #define LBA_SUP                 0x0200  /* 1=Logical Block Address support */
 245 #define DMA_SUP                 0x0100  /* 1=Direct Memory Access support */
 246 #define DMA_IL_SUP              0x8000  /* 1=interleaved DMA support (ATAPI) */
 247 #define CMD_Q_SUP               0x4000  /* 1=command queuing support (ATAPI) */
 248 #define OVLP_SUP                0x2000  /* 1=overlap operation support (ATAPI) */
 249 #define SWRST_REQ               0x1000  /* 1=ATA SW reset required (ATAPI, obsolete */
 250
 251 /* word 50: capabilities 1 */
 252 #define MIN_STANDBY_TIMER       0x0001  /* 1=device specific standby timer value minimum */
 253
 254 /* words 51 & 52: PIO & DMA cycle times */
 255 #define MODE                    0xff00  /* the mode is in the MSBs */
 256
 257 /* word 53: whats_valid */
 258 #define OK_W88                  0x0004  /* the ultra_dma info is valid */
 259 #define OK_W64_70               0x0002  /* see above for word descriptions */
 260 #define OK_W54_58               0x0001  /* current cyl, head, sector, cap. info valid */
 261
 262 /*word 63,88: dma_mode, ultra_dma_mode*/
 263 #define MODE_MAX                7       /* bit definitions force udma <=7 (when
 264                                          * udma >=8 comes out it'll have to be
 265                                          * defined in a new dma_mode word!) */
 266
 267 /* word 64: PIO transfer modes */
 268 #define PIO_SUP                 0x00ff  /* only bits 0 & 1 are used so far,  */
 269 #define PIO_MODE_MAX            8       /* but all 8 bits are defined        */
 270
 271 /* word 75: queue_depth */
 272 #define DEPTH_BITS              0x001f  /* bits used for queue depth */
 273
 274 /* words 80-81: version numbers */
 275 /* NOVAL_0 or  NOVAL_1 means device does not report version */
 276
 277 /* word 81: minor version number */
 278 #define MINOR_MAX               0x1C
 279 #ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY
 280 static const char * const minor_str[] = {                               /* word 81 value: */
 281         "device does not report version",               /* 0x0000       */
 282         "ATA-1 X3T9.2 781D prior to revision 4",        /* 0x0001       */
 283         "ATA-1 published, ANSI X3.221-1994",            /* 0x0002       */
 284         "ATA-1 X3T9.2 781D revision 4",                 /* 0x0003       */
 285         "ATA-2 published, ANSI X3.279-1996",            /* 0x0004       */
 286         "ATA-2 X3T10 948D prior to revision 2k",        /* 0x0005       */
 287         "ATA-3 X3T10 2008D revision 1",                 /* 0x0006       */
 288         "ATA-2 X3T10 948D revision 2k",                 /* 0x0007       */
 289         "ATA-3 X3T10 2008D revision 0",                 /* 0x0008       */
 290         "ATA-2 X3T10 948D revision 3",                  /* 0x0009       */
 291         "ATA-3 published, ANSI X3.298-199x",            /* 0x000a       */
 292         "ATA-3 X3T10 2008D revision 6",                 /* 0x000b       */
 293         "ATA-3 X3T13 2008D revision 7 and 7a",          /* 0x000c       */
 294         "ATA/ATAPI-4 X3T13 1153D revision 6",           /* 0x000d       */
 295         "ATA/ATAPI-4 T13 1153D revision 13",            /* 0x000e       */
 296         "ATA/ATAPI-4 X3T13 1153D revision 7",           /* 0x000f       */
 297         "ATA/ATAPI-4 T13 1153D revision 18",            /* 0x0010       */
 298         "ATA/ATAPI-4 T13 1153D revision 15",            /* 0x0011       */
 299         "ATA/ATAPI-4 published, ANSI NCITS 317-1998",   /* 0x0012       */
 300         "ATA/ATAPI-5 T13 1321D revision 3",
 301         "ATA/ATAPI-4 T13 1153D revision 14",            /* 0x0014       */
 302         "ATA/ATAPI-5 T13 1321D revision 1",             /* 0x0015       */
 303         "ATA/ATAPI-5 published, ANSI NCITS 340-2000",   /* 0x0016       */
 304         "ATA/ATAPI-4 T13 1153D revision 17",            /* 0x0017       */
 305         "ATA/ATAPI-6 T13 1410D revision 0",             /* 0x0018       */
 306         "ATA/ATAPI-6 T13 1410D revision 3a",            /* 0x0019       */
 307         "Reserved",                                     /* 0x001a       */
 308         "ATA/ATAPI-6 T13 1410D revision 2",             /* 0x001b       */
 309         "ATA/ATAPI-6 T13 1410D revision 1",             /* 0x001c       */
 310         "reserved"                                      /* 0x001d       */
 311         "reserved"                                      /* 0x001e       */
 312         "reserved"                                      /* 0x001f-0xfffe*/
 313 };
 314 #endif
 315 static const char actual_ver[] = {
 316                         /* word 81 value: */
 317         0,              /* 0x0000       WARNING:        */
 318         1,              /* 0x0001       WARNING:        */
 319         1,              /* 0x0002       WARNING:        */
 320         1,              /* 0x0003       WARNING:        */
 321         2,              /* 0x0004       WARNING:   This array           */
 322         2,              /* 0x0005       WARNING:   corresponds          */
 323         3,              /* 0x0006       WARNING:   *exactly*            */
 324         2,              /* 0x0007       WARNING:   to the ATA/          */
 325         3,              /* 0x0008       WARNING:   ATAPI version        */
 326         2,              /* 0x0009       WARNING:   listed in            */
 327         3,              /* 0x000a       WARNING:   the                  */
 328         3,              /* 0x000b       WARNING:   minor_str            */
 329         3,              /* 0x000c       WARNING:   array                */
 330         4,              /* 0x000d       WARNING:   above.               */
 331         4,              /* 0x000e       WARNING:                        */
 332         4,              /* 0x000f       WARNING:   if you change        */
 333         4,              /* 0x0010       WARNING:   that one,            */
 334         4,              /* 0x0011       WARNING:   change this one      */
 335         4,              /* 0x0012       WARNING:   too!!!               */
 336         5,              /* 0x0013       WARNING:        */
 337         4,              /* 0x0014       WARNING:        */
 338         5,              /* 0x0015       WARNING:        */
 339         5,              /* 0x0016       WARNING:        */
 340         4,              /* 0x0017       WARNING:        */
 341         6,              /* 0x0018       WARNING:        */
 342         6,              /* 0x0019       WARNING:        */
 343         0,              /* 0x001a       WARNING:        */
 344         6,              /* 0x001b       WARNING:        */
 345         6,              /* 0x001c       WARNING:        */
 346         0               /* 0x001d-0xfffe                */
 347 };
 348
 349 /* words 82-84: cmds/feats supported */
 350 #define CMDS_W82                0x77ff  /* word 82: defined command locations*/
 351 #define CMDS_W83                0x3fff  /* word 83: defined command locations*/
 352 #define CMDS_W84                0x002f  /* word 83: defined command locations*/
 353 #define SUPPORT_48_BIT          0x0400
 354 #define NUM_CMD_FEAT_STR        48
 355
 356 #ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY
 357 static const char * const cmd_feat_str[] = {
 358         "",                                     /* word 82 bit 15: obsolete  */
 359         "NOP cmd",                              /* word 82 bit 14 */
 360         "READ BUFFER cmd",                      /* word 82 bit 13 */
 361         "WRITE BUFFER cmd",                     /* word 82 bit 12 */
 362         "",                                     /* word 82 bit 11: obsolete  */
 363         "Host Protected Area feature set",      /* word 82 bit 10 */
 364         "DEVICE RESET cmd",                     /* word 82 bit  9 */
 365         "SERVICE interrupt",                    /* word 82 bit  8 */
 366         "Release interrupt",                    /* word 82 bit  7 */
 367         "Look-ahead",                           /* word 82 bit  6 */
 368         "Write cache",                          /* word 82 bit  5 */
 369         "PACKET command feature set",           /* word 82 bit  4 */
 370         "Power Management feature set",         /* word 82 bit  3 */
 371         "Removable Media feature set",          /* word 82 bit  2 */
 372         "Security Mode feature set",            /* word 82 bit  1 */
 373         "SMART feature set",                    /* word 82 bit  0 */
 374                                                 /* --------------*/
 375         "",                                     /* word 83 bit 15: !valid bit */
 376         "",                                     /* word 83 bit 14:  valid bit */
 377         "FLUSH CACHE EXT command",              /* word 83 bit 13 */
 378         "Mandatory FLUSH CACHE command ",       /* word 83 bit 12 */
 379         "Device Configuration Overlay feature set ",
 380         "48-bit Address feature set ",          /* word 83 bit 10 */
 381         "",
 382         "SET MAX security extension",           /* word 83 bit  8 */
 383         "Address Offset Reserved Area Boot",    /* word 83 bit  7 */
 384         "SET FEATURES subcommand required to spinup after power up",
 385         "Power-Up In Standby feature set",      /* word 83 bit  5 */
 386         "Removable Media Status Notification feature set",
 387         "Adv. Power Management feature set",/* word 83 bit  3 */
 388         "CFA feature set",                      /* word 83 bit  2 */
 389         "READ/WRITE DMA QUEUED",                /* word 83 bit  1 */
 390         "DOWNLOAD MICROCODE cmd",               /* word 83 bit  0 */
 391                                                 /* --------------*/
 392         "",                                     /* word 84 bit 15: !valid bit */
 393         "",                                     /* word 84 bit 14:  valid bit */
 394         "",                                     /* word 84 bit 13:  reserved */
 395         "",                                     /* word 84 bit 12:  reserved */
 396         "",                                     /* word 84 bit 11:  reserved */
 397         "",                                     /* word 84 bit 10:  reserved */
 398         "",                                     /* word 84 bit  9:  reserved */
 399         "",                                     /* word 84 bit  8:  reserved */
 400         "",                                     /* word 84 bit  7:  reserved */
 401         "",                                     /* word 84 bit  6:  reserved */
 402         "General Purpose Logging feature set",  /* word 84 bit  5 */
 403         "",                                     /* word 84 bit  4:  reserved */
 404         "Media Card Pass Through Command feature set ",
 405         "Media serial number ",                 /* word 84 bit  2 */
 406         "SMART self-test ",                     /* word 84 bit  1 */
 407         "SMART error logging "                  /* word 84 bit  0 */
 408 };
 409 #endif
 410
 411
 412 /* words 85-87: cmds/feats enabled */
 413 /* use cmd_feat_str[] to display what commands and features have
 414  * been enabled with words 85-87
 415  */
 416
 417 /* words 89, 90, SECU ERASE TIME */
 418 #define ERASE_BITS              0x00ff
 419
 420 /* word 92: master password revision */
 421 /* NOVAL_0 or  NOVAL_1 means no support for master password revision */
 422
 423 /* word 93: hw reset result */
 424 #define CBLID                   0x2000  /* CBLID status */
 425 #define RST0                    0x0001  /* 1=reset to device #0 */
 426 #define DEV_DET                 0x0006  /* how device num determined */
 427 #define JUMPER_VAL              0x0002  /* device num determined by jumper */
 428 #define CSEL_VAL                0x0004  /* device num determined by CSEL_VAL */
 429
 430 /* word 127: removable media status notification feature set support */
 431 #define RM_STAT_BITS            0x0003
 432 #define RM_STAT_SUP             0x0001
 433
 434 /* word 128: security */
 435 #define SECU_ENABLED    0x0002
 436 #define SECU_LEVEL              0x0010
 437 #define NUM_SECU_STR    6
 438 #ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY
 439 static const char * const secu_str[] = {
 440         "supported",                    /* word 128, bit 0 */
 441         "enabled",                      /* word 128, bit 1 */
 442         "locked",                       /* word 128, bit 2 */
 443         "frozen",                       /* word 128, bit 3 */
 444         "expired: security count",      /* word 128, bit 4 */
 445         "supported: enhanced erase"     /* word 128, bit 5 */
 446 };
 447 #endif
 448
 449 /* word 160: CFA power mode */
 450 #define VALID_W160              0x8000  /* 1=word valid */
 451 #define PWR_MODE_REQ            0x2000  /* 1=CFA power mode req'd by some cmds*/
 452 #define PWR_MODE_OFF            0x1000  /* 1=CFA power moded disabled */
 453 #define MAX_AMPS                0x0fff  /* value = max current in ma */
 454
 455 /* word 255: integrity */
 456 #define SIG                     0x00ff  /* signature location */
 457 #define SIG_VAL                 0x00A5  /* signature value */
 458
 459 #define VERSION "v5.4"
 460
 461 #define TIMING_MB               64
 462 #define TIMING_BUF_MB           1
 463 #define TIMING_BUF_BYTES        (TIMING_BUF_MB * 1024 * 1024)
 464 #define TIMING_BUF_COUNT        (timing_MB / TIMING_BUF_MB)
 465 #define BUFCACHE_FACTOR         2
 466
 467 #undef DO_FLUSHCACHE            /* under construction: force cache flush on -W0 */
 468
 469 /* Busybox messages and functions */
 470
 471 static const char bb_msg_shared_mem[] = "could not %s sharedmem buf";
 472 static const char bb_msg_op_not_supp[] = " operation not supported on %s disks";
 473
 474 static void bb_ioctl(int fd, int request, void *argp, const char *string)
 475 {
 476         if (ioctl (fd, request, argp) != 0)
 477                 bb_perror_msg(" %s", string);
 478 }
 479
 480 static void if_printf(unsigned long i, char *fmt, ... )
 481 {
 482                 va_list ap;
 483                 va_start(ap, fmt);
 484                 if (i)
 485                         vprintf(fmt, ap);
 486                 va_end(ap);
 487 }
 488
 489 static void on_off (unsigned int value);
 490
 491 static void if_printf_on_off(unsigned long get_arg,const char *fmt, unsigned long arg)
 492 {
 493         if (get_arg)
 494         {
 495                 printf(fmt, arg);
 496                 on_off(arg);
 497         }
 498 }
 499
 500 static void bb_ioctl_on_off(int fd, int request, void *argp, const char *string,
 501                                                          const char * fmt)
 502 {
 503         if (ioctl (fd, request, &argp) != 0)
 504                 bb_perror_msg(" %s", string);
 505         else
 506         {
 507                 printf(fmt, (unsigned long) argp);
 508                 on_off((unsigned long) argp);
 509         }
 510 }
 511
 512 #ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY
 513 static void if_else_printf(unsigned long i, char *fmt1, char *fmt2, ... )
 514 {
 515                 va_list ap;
 516                 va_start(ap, fmt2);
 517                 if (i)
 518                         vprintf(fmt1, ap);
 519                 else
 520                         vprintf(fmt2, ap);
 521                 va_end(ap);
 522 }
 523
 524 static void print_ascii(uint16_t *p, uint8_t length);
 525
 526 static void xprint_ascii(uint16_t *val ,int i, char * string, int n)
 527 {
 528         if(val[i])
 529         {
 530                 printf("\t%-20s",string);
 531                 print_ascii(&val[i], n);
 532         }
 533 }
 534
 535 static void if_strcat(unsigned long test, char *modes, char *string)
 536 {
 537         if (test)
 538                 strcat(modes,string);
 539 }
 540 #endif
 541
 542 static void sync_and_sleep(int i)
 543 {
 544         sync();
 545         sleep(i);
 546 }
 547
 548 static uint16_t check_if_min_and_set_val(uint16_t a, uint16_t b)
 549 {
 550         if( a < b)
 551                 a = b;
 552         return a;
 553 }
 554
 555 static uint16_t check_if_maj_and_set_val(uint16_t a, uint16_t b)
 556 {
 557         if( a > b)
 558                 a = b;
 559         return a;
 560 }
 561
 562 static unsigned long int set_flag(char *p, char max)
 563 {
 564         if (*p >= '0' && *p <=  max )
 565                 return 1;
 566         return 0;
 567 }
 568
 569 /* end of  busybox specific stuff */
 570
 571 #ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY
 572 static uint8_t mode_loop(uint16_t mode_sup, uint16_t mode_sel, int cc, uint8_t *have_mode)
 573 {
 574         uint16_t ii;
 575         uint8_t err_dma = 0;
 576
 577         for(ii = 0; ii <= MODE_MAX; ii++)
 578         {
 579                 if(mode_sel & 0x0001)
 580                 {
 581                         printf("*%cdma%u ",cc,ii);
 582                         if(*have_mode)
 583                                 err_dma = 1;
 584                         *have_mode = 1;
 585                 }
 586                 else if(mode_sup & 0x0001)
 587                         printf("%cdma%u ",cc,ii);
 588
 589                 mode_sup >>=1;
 590                 mode_sel >>=1;
 591         }
 592         return err_dma;
 593 }
 594
 595 static void print_ascii(uint16_t *p, uint8_t length) {
 596         uint8_t ii;
 597         char cl;
 598
 599         /* find first non-space & print it */
 600         for(ii = 0; ii< length; ii++)
 601         {
 602                 if(((char) 0x00ff&((*p)>>8)) != ' ')
 603                         break;
 604                 if((cl = (char) 0x00ff&(*p)) != ' ')
 605                 {
 606                         if_printf((cl != '\0'),"%c",cl);
 607                         p++;
 608                         ii++;
 609                         break;
 610                 }
 611                 p++;
 612         }
 613         /* print the rest */
 614         for(; ii< length; ii++)
 615         {
 616                 if(!(*p))
 617                         break; /* some older devices have NULLs */
 618                 printf("%c%c",(char)0x00ff&((*p)>>8),(char)(*p)&0x00ff);
 619                 p++;
 620         }
 621         printf("\n");
 622 }
 623
 624 /* identify() is the only extern function used across two source files.  The
 625    others, though, were declared in hdparm.c with global scope; since other
 626    functions in that file have static (file) scope, I assume the difference is
 627    intentional. */
 628 static void identify (uint16_t *id_supplied, const char *devname)
 629 {
 630
 631         char *id_file = NULL;
 632         FILE *fl;
 633         uint16_t val[256], ii, jj, kk;
 634         uint16_t like_std = 1, std = 0, min_std = 0xffff;
 635         uint16_t dev = NO_DEV, eqpt = NO_DEV;
 636         uint8_t  have_mode = 0, err_dma = 0;
 637         uint8_t  chksum = 0;
 638         uint32_t ll, mm, nn, oo;
 639         __u64 bbbig; /* (:) */
 640
 641         if (id_supplied)
 642         {
 643 #if __BYTE_ORDER == __BIG_ENDIAN
 644                 swab(id_supplied, val, sizeof(val));
 645 #else
 646                 memcpy(val, id_supplied, sizeof(val));
 647 #endif
 648         }
 649         else
 650         {
 651                 id_file = xcalloc(1, strlen(devname)+22);
 652                 sprintf(id_file, "/proc/ide/%s/identify", devname);
 653                 /* open the file, read in all the info and close it */
 654                 if (id_file == NULL)
 655                         fl = stdin;
 656                 else
 657                         fl = bb_xfopen(id_file, "r");
 658
 659                 /* calculate checksum over all bytes */
 660                 for(ii = GEN_CONFIG; ii<=INTEGRITY; ii++)
 661                 {
 662                         unsigned int scratch;
 663                         if(1 != fscanf(fl,"%04x",&scratch))
 664                                 break;
 665                         val[ii] = (uint16_t)scratch;
 666                         chksum += val[ii] + (val[ii] >> 8);
 667                 }
 668                 fclose(fl);
 669                 /*bb_fclose_nonstdin(fl);*/
 670                 if(ii < (INTEGRITY+1))
 671                         bb_error_msg_and_die("Input file wrong format or length");
 672         }
 673         chksum &= 0xff;
 674
 675         /* check if we recognise the device type */
 676         printf("\n");
 677         if(!(val[GEN_CONFIG] & NOT_ATA))
 678         {
 679                 dev = ATA_DEV;
 680                 printf("ATA device, with ");
 681         }
 682         else if(val[GEN_CONFIG]==CFA_SUPPORT_VAL)
 683         {
 684                 dev = ATA_DEV;
 685                 like_std = 4;
 686                 printf("CompactFlash ATA device, with ");
 687         }
 688         else if(!(val[GEN_CONFIG] & NOT_ATAPI))
 689         {
 690                 dev = ATAPI_DEV;
 691                 eqpt = (val[GEN_CONFIG] & EQPT_TYPE) >> SHIFT_EQPT;
 692                 printf("ATAPI %s, with ", pkt_str[eqpt]);
 693                 like_std = 3;
 694         }
 695         else
 696                 /*"Unknown device type:\n\tbits 15&14 of general configuration word 0 both set to 1.\n"*/
 697                 bb_error_msg_and_die("Unknown device type");
 698
 699         if_printf(!(val[GEN_CONFIG] & MEDIA_REMOVABLE),"non-");
 700         printf("removable media\n");
 701
 702         /* Info from the specific configuration word says whether or not the
 703          * ID command completed correctly.  It is only defined, however in
 704          * ATA/ATAPI-5 & 6; it is reserved (value theoretically 0) in prior
 705          * standards.  Since the values allowed for this word are extremely
 706          * specific, it should be safe to check it now, even though we don't
 707          * know yet what standard this device is using.
 708          */
 709         if((val[CONFIG]==STBY_NID_VAL) || (val[CONFIG]==STBY_ID_VAL) ||
 710            (val[CONFIG]==PWRD_NID_VAL) || (val[CONFIG]==PWRD_ID_VAL) )
 711         {
 712                 like_std = 5;
 713                 if_printf(((val[CONFIG]==STBY_NID_VAL) || (val[CONFIG]==STBY_ID_VAL)),
 714                                         "powers-up in standby; SET FEATURES subcmd spins-up.\n");
 715                 if_printf((((val[CONFIG]==STBY_NID_VAL) || (val[CONFIG]==PWRD_NID_VAL)) && (val[GEN_CONFIG] & INCOMPLETE)),
 716                                         "\n\tWARNING: ID response incomplete.\n\tFollowing data may be incorrect.\n\n");
 717         }
 718
 719         /* output the model and serial numbers and the fw revision */
 720         xprint_ascii(val, START_MODEL,  "Model Number:",        LENGTH_MODEL);
 721         xprint_ascii(val, START_SERIAL, "Serial Number:",       LENGTH_SERIAL);
 722         xprint_ascii(val, START_FW_REV, "Firmware Revision:",   LENGTH_FW_REV);
 723         xprint_ascii(val, START_MEDIA,  "Media Serial Num:",    LENGTH_MEDIA);
 724         xprint_ascii(val, START_MANUF,  "Media Manufacturer:",  LENGTH_MANUF);
 725
 726         /* major & minor standards version number (Note: these words were not
 727          * defined until ATA-3 & the CDROM std uses different words.) */
 728         printf("Standards:");
 729         if(eqpt != CDROM)
 730         {
 731                 if(val[MINOR] && (val[MINOR] <= MINOR_MAX))
 732                 {
 733                         like_std=check_if_min_and_set_val(like_std, 3);
 734                         std = actual_ver[val[MINOR]];
 735                         if_printf(std,"\n\tUsed: %s ",minor_str[val[MINOR]]);
 736
 737                 }
 738                 /* looks like when they up-issue the std, they obsolete one;
 739                  * thus, only the newest 4 issues need be supported. (That's
 740                  * what "kk" and "min_std" are all about.) */
 741                 if(val[MAJOR] && (val[MAJOR] !=NOVAL_1))
 742                 {
 743                         printf("\n\tSupported: ");
 744                         jj = val[MAJOR] << 1;
 745                         kk = like_std >4 ? like_std-4: 0;
 746                         for(ii = 14; (ii >0)&&(ii>kk); ii--)
 747                         {
 748                                 if(jj & 0x8000)
 749                                 {
 750                                         printf("%u ", ii);
 751                                         if(like_std < ii)
 752                                         {
 753                                                 like_std = ii;
 754                                                 kk = like_std >4 ? like_std-4: 0;
 755                                         }
 756                                         min_std=check_if_maj_and_set_val(min_std, ii);
 757                                 }
 758                                 jj <<= 1;
 759                         }
 760                         like_std=check_if_min_and_set_val(like_std, 3);
 761                 }
 762                 /* Figure out what standard the device is using if it hasn't told
 763                  * us.  If we know the std, check if the device is using any of
 764                  * the words from the next level up.  It happens.
 765                  */
 766                 like_std=check_if_min_and_set_val(like_std, std);
 767
 768                 if(((std == 5) || (!std && (like_std < 6))) &&
 769                         ((((val[CMDS_SUPP_1] & VALID) == VALID_VAL) &&
 770                         ((      val[CMDS_SUPP_1] & CMDS_W83) > 0x00ff)) ||
 771                         (((     val[CMDS_SUPP_2] & VALID) == VALID_VAL) &&
 772                         (       val[CMDS_SUPP_2] & CMDS_W84) ) ) )
 773                 {
 774                         like_std = 6;
 775                 }
 776                 else if(((std == 4) || (!std && (like_std < 5))) &&
 777                         ((((val[INTEGRITY]      & SIG) == SIG_VAL) && !chksum) ||
 778                         ((      val[HWRST_RSLT] & VALID) == VALID_VAL) ||
 779                         (((     val[CMDS_SUPP_1] & VALID) == VALID_VAL) &&
 780                         ((      val[CMDS_SUPP_1] & CMDS_W83) > 0x001f)) ) )
 781                 {
 782                         like_std = 5;
 783                 }
 784                 else if(((std == 3) || (!std && (like_std < 4))) &&
 785                                 ((((val[CMDS_SUPP_1] & VALID) == VALID_VAL) &&
 786                                 (((     val[CMDS_SUPP_1] & CMDS_W83) > 0x0000) ||
 787                                 ((      val[CMDS_SUPP_0] & CMDS_W82) > 0x000f))) ||
 788                                 ((      val[CAPAB_1] & VALID) == VALID_VAL) ||
 789                                 ((      val[WHATS_VALID] & OK_W88) && val[ULTRA_DMA]) ||
 790                                 ((      val[RM_STAT] & RM_STAT_BITS) == RM_STAT_SUP) ) )
 791                 {
 792                         like_std = 4;
 793                 }
 794                 else if(((std == 2) || (!std && (like_std < 3))) &&
 795                            ((val[CMDS_SUPP_1] & VALID) == VALID_VAL) )
 796                 {
 797                         like_std = 3;
 798                 }
 799                 else if(((std == 1) || (!std && (like_std < 2))) &&
 800                                 ((val[CAPAB_0] & (IORDY_SUP | IORDY_OFF)) ||
 801                                 (val[WHATS_VALID] & OK_W64_70)) )
 802                 {
 803                         like_std = 2;
 804                 }
 805                 if(!std)
 806                         printf("\n\tLikely used: %u\n",like_std);
 807                 else if(like_std > std)
 808                         printf("& some of %u\n",like_std);
 809                 else
 810                         printf("\n");
 811         }
 812         else
 813         {
 814                 /* TBD: do CDROM stuff more thoroughly.  For now... */
 815                 kk = 0;
 816                 if(val[CDR_MINOR] == 9)
 817                 {
 818                         kk = 1;
 819                         printf("\n\tUsed: ATAPI for CD-ROMs, SFF-8020i, r2.5");
 820                 }
 821                 if(val[CDR_MAJOR] && (val[CDR_MAJOR] !=NOVAL_1))
 822                 {
 823                         kk = 1;
 824                         printf("\n\tSupported: CD-ROM ATAPI");
 825                         jj = val[CDR_MAJOR] >> 1;
 826                         for(ii = 1; ii <15; ii++)
 827                         {
 828                                 if_printf((jj & 0x0001),"-%u ", ii);
 829                                 jj >>= 1;
 830                         }
 831                 }
 832                 if_else_printf((!kk),"\n\tLikely used CD-ROM ATAPI-1\n","\n");
 833                 /* the cdrom stuff is more like ATA-2 than anything else, so: */
 834                 like_std = 2;
 835         }
 836
 837         if(min_std == 0xffff)
 838                 min_std = like_std > 4 ? like_std - 3 : 1;
 839
 840         printf("Configuration:\n");
 841         /* more info from the general configuration word */
 842         if((eqpt != CDROM) && (like_std == 1))
 843         {
 844                 jj = val[GEN_CONFIG] >> 1;
 845                 for(ii = 1; ii < 15; ii++)
 846                 {
 847                         if_printf((jj & 0x0001),"\t%s\n",ata1_cfg_str[ii]);
 848                         jj >>=1;
 849                 }
 850         }
 851         if(dev == ATAPI_DEV)
 852         {
 853                 printf("\tDRQ response: "); /* Data Request (DRQ) */
 854                 switch(val[GEN_CONFIG] & DRQ_RESPONSE_TIME)
 855                 {
 856                         case DRQ_3MS_VAL :
 857                                 printf("3ms.\n");
 858                                 break;
 859                         case DRQ_INTR_VAL :
 860                                 printf("<=10ms with INTRQ\n");
 861                                 break;
 862                         case DRQ_50US_VAL :
 863                                 printf("50us.\n");
 864                                 break;
 865                         default :
 866                                 printf("unknown.\n");
 867                                 break;
 868                 }
 869                 printf("\tPacket size: ");
 870                 switch(val[GEN_CONFIG] & PKT_SIZE_SUPPORTED)
 871                 {
 872                         case PKT_SIZE_12_VAL :
 873                                 printf("12 bytes\n");
 874                                 break;
 875                         case PKT_SIZE_16_VAL :
 876                                 printf("16 bytes\n");
 877                                 break;
 878                         default :
 879                                 printf("Unknown\n");
 880                                 break;
 881                 }
 882         }
 883         else
 884         {
 885                 /* addressing...CHS? See section 6.2 of ATA specs 4 or 5 */
 886                 ll = (uint32_t)val[LBA_SECTS_MSB] << 16 | val[LBA_SECTS_LSB];
 887                 mm = 0; bbbig = 0;
 888                 if ( (ll > 0x00FBFC10) && (!val[LCYLS]))
 889                         printf("\tCHS addressing not supported\n");
 890                 else
 891                 {
 892                         jj = val[WHATS_VALID] & OK_W54_58;
 893                         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",
 894                                         val[LCYLS],jj?val[LCYLS_CUR]:0, val[LHEADS],jj?val[LHEADS_CUR]:0, val[LSECTS],jj?val[LSECTS_CUR]:0);
 895
 896                         if_printf(((min_std == 1) && (val[TRACK_BYTES] || val[SECT_BYTES])),
 897                                                 "\tbytes/track: %u\tbytes/sector: %u\n",val[TRACK_BYTES], val[SECT_BYTES]);
 898
 899                         if(jj)
 900                         {
 901                                 mm = (uint32_t)val[CAPACITY_MSB] << 16 | val[CAPACITY_LSB];
 902                                 if(like_std < 3)
 903                                 {
 904                                          /* check Endian of capacity bytes */
 905                                         nn = val[LCYLS_CUR] * val[LHEADS_CUR] * val[LSECTS_CUR];
 906                                         oo = (uint32_t)val[CAPACITY_LSB] << 16 | val[CAPACITY_MSB];
 907                                         if(abs(mm - nn) > abs(oo - nn))
 908                                                 mm = oo;
 909                                 }
 910                                 printf("\tCHS current addressable sectors:%11u\n",mm);
 911                         }
 912                 }
 913                 /* LBA addressing */
 914                 printf("\tLBA    user addressable sectors:%11u\n",ll);
 915                 if( ((val[CMDS_SUPP_1] & VALID) == VALID_VAL) &&
 916                      (val[CMDS_SUPP_1] & SUPPORT_48_BIT) )
 917                 {
 918                         bbbig = (__u64)val[LBA_64_MSB]  << 48 |
 919                                 (__u64)val[LBA_48_MSB]  << 32 |
 920                                 (__u64)val[LBA_MID]     << 16 |
 921                                         val[LBA_LSB] ;
 922                         printf("\tLBA48  user addressable sectors:%11llu\n",bbbig);
 923                 }
 924
 925                 if (!bbbig)
 926                         bbbig = (__u64)(ll>mm ? ll : mm); /* # 512 byte blocks */
 927                 printf("\tdevice size with M = 1024*1024: %11llu MBytes\n",bbbig>>11);
 928                 bbbig = (bbbig<<9)/1000000;
 929                 printf("\tdevice size with M = 1000*1000: %11llu MBytes ",bbbig);
 930
 931                 if_else_printf((bbbig > 1000),"(%llu GB)\n","\n",bbbig/1000);
 932
 933         }
 934
 935         /* hw support of commands (capabilities) */
 936         printf("Capabilities:\n\t");
 937
 938         if(dev == ATAPI_DEV)
 939         {
 940                 if(eqpt != CDROM)
 941                         if_printf((val[CAPAB_0] & CMD_Q_SUP),"Cmd queuing, ");
 942
 943                 if_printf((val[CAPAB_0] & OVLP_SUP),"Cmd overlap, ");
 944         }
 945         if_printf((val[CAPAB_0] & LBA_SUP),"LBA, ");
 946
 947         if(like_std != 1)
 948         {
 949                 printf("IORDY");
 950                 if_printf((!(val[CAPAB_0] & IORDY_SUP)),"(may be)");
 951                 if_else_printf((val[CAPAB_0] & IORDY_OFF),"(can","(cannot");
 952                 printf(" be disabled)\n");
 953         }
 954         else
 955                 printf("no IORDY\n");
 956
 957         if((like_std == 1) && val[BUF_TYPE])
 958         {
 959                 kk = val[BUF_TYPE];
 960                 printf("\tBuffer type: %04x: ",kk);
 961                 if_else_printf((kk < 2),"single port, single-sector","dual port, multi-sector");
 962                 if_printf((kk > 2)," with read caching ability");
 963                 printf("\n");
 964         }
 965         jj = 0;
 966         if((min_std == 1) && (val[BUFFER__SIZE] && (val[BUFFER__SIZE] != NOVAL_1)))
 967         {
 968                 printf("\tBuffer size: %.1fkB",(float)val[BUFFER__SIZE]/2);
 969                 jj = 1;
 970         }
 971         if((min_std < 4) && (val[RW_LONG]))
 972         {
 973                 printf("\tbytes avail on r/w long: %u",val[RW_LONG]);
 974                 jj = 1;
 975         }
 976         if((eqpt != CDROM) && (like_std > 3))
 977         {
 978                 printf("\tQueue depth: %u",(val[QUEUE_DEPTH] & DEPTH_BITS)+1);
 979                 jj = 1;
 980         }
 981         if_printf(jj,"\n");
 982
 983         if(dev == ATA_DEV)
 984         {
 985                 if(like_std == 1)
 986                         printf("\tCan%s perform double-word IO\n",(!val[DWORD_IO]) ?"not":"");
 987                 else
 988                 {
 989                         printf("\tStandby timer values: spec'd by ");
 990                         if_else_printf((val[CAPAB_0] & STD_STBY),"Standard","Vendor");
 991                         if((like_std > 3) && ((val[CAPAB_1] & VALID) == VALID_VAL))
 992                                 printf(", %s device specific minimum\n",(val[CAPAB_1] & MIN_STANDBY_TIMER)?"with":"no");
 993                         else
 994                           printf("\n");
 995                 }
 996                 printf("\tR/W multiple sector transfer: ");
 997                 if((like_std < 3) && !(val[SECTOR_XFER_MAX] & SECTOR_XFER))
 998                         printf("not supported\n");
 999                 else
1000                 {
1001                         printf("Max = %u\tCurrent = ",val[SECTOR_XFER_MAX] & SECTOR_XFER);
1002                         if_else_printf((val[SECTOR_XFER_CUR] & MULTIPLE_SETTING_VALID),
1003                                                         "%u\n","?\n",val[SECTOR_XFER_CUR] & SECTOR_XFER);
1004                 }
1005                 if((like_std > 3) && (val[CMDS_SUPP_1] & 0x0008))
1006                 {
1007                         /* We print out elsewhere whether the APM feature is enabled or
1008                            not.  If it's not enabled, let's not repeat the info; just print
1009                            nothing here. */
1010                         printf("\tAdvancedPM level: ");
1011                         if ( (val[ADV_PWR] & 0xFF00) == 0x4000 )
1012                         {
1013                                 uint8_t apm_level = val[ADV_PWR] & 0x00FF;
1014                                 printf("%u (0x%x)\n", apm_level, apm_level);
1015                         }
1016                         else
1017                                 printf("unknown setting (0x%04x)\n", val[ADV_PWR]);
1018                 }
1019                 if(like_std > 5)
1020                 {
1021                         if_printf(val[ACOUSTIC],"\tRecommended acoustic management value: %u, current value: %u\n",
1022                                                                         (val[ACOUSTIC] >> 8) & 0x00ff, val[ACOUSTIC] & 0x00ff);
1023                 }
1024         }
1025         else
1026         {
1027                  /* ATAPI */
1028                 if(eqpt != CDROM)
1029                         if_printf((val[CAPAB_0] & SWRST_REQ),"\tATA sw reset required\n");
1030
1031                 if(val[PKT_REL] || val[SVC_NBSY])
1032                 {
1033                         printf("\tOverlap support:");
1034                         if_printf(val[PKT_REL]," %uus to release bus.",val[PKT_REL]);
1035                         if_printf(val[SVC_NBSY]," %uus to clear BSY after SERVICE cmd.",val[SVC_NBSY]);
1036                         printf("\n");
1037                 }
1038         }
1039
1040         /* DMA stuff. Check that only one DMA mode is selected. */
1041         printf("\tDMA: ");
1042         if(!(val[CAPAB_0] & DMA_SUP))
1043                 printf("not supported\n");
1044         else
1045         {
1046                 if_printf((val[DMA_MODE] && !val[SINGLE_DMA] && !val[MULTI_DMA]),
1047                                         " sdma%u\n",(val[DMA_MODE] & MODE) >> 8);
1048                 if(val[SINGLE_DMA])
1049                 {
1050                         jj = val[SINGLE_DMA];
1051                         kk = val[SINGLE_DMA] >> 8;
1052                         err_dma += mode_loop(jj,kk,'s',&have_mode);
1053                 }
1054                 if(val[MULTI_DMA])
1055                 {
1056                         jj = val[MULTI_DMA];
1057                         kk = val[MULTI_DMA] >> 8;
1058                         err_dma += mode_loop(jj,kk,'m',&have_mode);
1059                 }
1060                 if((val[WHATS_VALID] & OK_W88) && val[ULTRA_DMA])
1061                 {
1062                         jj = val[ULTRA_DMA];
1063                         kk = val[ULTRA_DMA] >> 8;
1064                         err_dma += mode_loop(jj,kk,'u',&have_mode);
1065                 }
1066                 if_printf((err_dma || !have_mode),"(?)");
1067                 printf("\n");
1068
1069                 if_printf(((dev == ATAPI_DEV) && (eqpt != CDROM) && (val[CAPAB_0] & DMA_IL_SUP)),
1070                                         "\t     Interleaved DMA support\n");
1071
1072                 if((val[WHATS_VALID] & OK_W64_70) &&
1073                    (val[DMA_TIME_MIN] || val[DMA_TIME_NORM]))
1074                 {
1075                         printf("\t     Cycle time:");
1076                         if_printf(val[DMA_TIME_MIN]," min=%uns",val[DMA_TIME_MIN]);
1077                         if_printf(val[DMA_TIME_NORM]," recommended=%uns",val[DMA_TIME_NORM]);
1078                         printf("\n");
1079                 }
1080         }
1081
1082         /* Programmed IO stuff */
1083         printf("\tPIO: ");
1084         /* If a drive supports mode n (e.g. 3), it also supports all modes less
1085          * than n (e.g. 3, 2, 1 and 0).  Print all the modes. */
1086         if((val[WHATS_VALID] & OK_W64_70) && (val[ADV_PIO_MODES] & PIO_SUP))
1087         {
1088                 jj = ((val[ADV_PIO_MODES] & PIO_SUP) << 3) | 0x0007;
1089                 for(ii = 0; ii <= PIO_MODE_MAX ; ii++)
1090                 {
1091                         if_printf((jj & 0x0001),"pio%d ",ii);
1092                         jj >>=1;
1093                 }
1094                 printf("\n");
1095         }
1096         else if(((min_std < 5) || (eqpt == CDROM)) && (val[PIO_MODE] & MODE) )
1097         {
1098                 for(ii = 0; ii <= val[PIO_MODE]>>8; ii++)
1099                         printf("pio%d ",ii);
1100                 printf("\n");
1101         }
1102         else
1103                 printf("unknown\n");
1104
1105         if(val[WHATS_VALID] & OK_W64_70)
1106         {
1107                 if(val[PIO_NO_FLOW] || val[PIO_FLOW])
1108                 {
1109                         printf("\t     Cycle time:");
1110                         if_printf(val[PIO_NO_FLOW]," no flow control=%uns", val[PIO_NO_FLOW]);
1111                         if_printf(val[PIO_FLOW],"  IORDY flow control=%uns", val[PIO_FLOW]);
1112                         printf("\n");
1113                 }
1114         }
1115
1116         if((val[CMDS_SUPP_1] & VALID) == VALID_VAL)
1117         {
1118                 printf("Commands/features:\n\tEnabled\tSupported:\n");
1119                 jj = val[CMDS_SUPP_0];
1120                 kk = val[CMDS_EN_0];
1121                 for(ii = 0; ii < NUM_CMD_FEAT_STR; ii++)
1122                 {
1123                         if((jj & 0x8000) && (*cmd_feat_str[ii] != '\0'))
1124                         {
1125                                 if_else_printf((kk & 0x8000),"\t   *","\t");
1126                                 printf("\t%s\n",cmd_feat_str[ii]);
1127                         }
1128                         jj <<=1; kk<<=1;
1129                         if(ii%16 == 15)
1130                         {
1131                                 jj = val[CMDS_SUPP_0+1+(ii/16)];
1132                                 kk = val[CMDS_EN_0+1+(ii/16)];
1133                         }
1134                         if(ii == 31)
1135                         {
1136                                 if((val[CMDS_SUPP_2] & VALID) != VALID_VAL)
1137                                         ii +=16;
1138                         }
1139                 }
1140         }
1141         if_printf(((val[RM_STAT] & RM_STAT_BITS) == RM_STAT_SUP),
1142                                 "\tRemovable Media Status Notification feature set supported\n");
1143
1144
1145         /* security */
1146         if((eqpt != CDROM) && (like_std > 3) &&
1147            (val[SECU_STATUS] || val[ERASE_TIME] || val[ENH_ERASE_TIME]))
1148         {
1149                 printf("Security: \n");
1150                 if_printf((val[PSWD_CODE] && (val[PSWD_CODE] != NOVAL_1)),
1151                                         "\tMaster password revision code = %u\n",val[PSWD_CODE]);
1152                 jj = val[SECU_STATUS];
1153                 if(jj)
1154                 {
1155                         for(ii = 0; ii < NUM_SECU_STR; ii++)
1156                         {
1157                                 if_else_printf((!(jj & 0x0001)),"\tnot\t%s\n", "\t\t%s\n", secu_str[ii]);
1158                                 jj >>=1;
1159                         }
1160                         if(val[SECU_STATUS] & SECU_ENABLED)
1161                         {
1162                                 printf("\tSecurity level ");
1163                                 if_else_printf((val[SECU_STATUS] & SECU_LEVEL),"maximum\n","high\n");
1164                         }
1165                 }
1166                 jj =  val[ERASE_TIME]     & ERASE_BITS;
1167                 kk =  val[ENH_ERASE_TIME] & ERASE_BITS;
1168                 if(jj || kk)
1169                 {
1170                         printf("\t");
1171                         if_printf(jj,"%umin for SECURITY ERASE UNIT. ", jj==ERASE_BITS ? 508 : jj<<1);
1172                         if_printf(kk,"%umin for ENHANCED SECURITY ERASE UNIT.", kk==ERASE_BITS ? 508 : kk<<1);
1173                         printf("\n");
1174                 }
1175         }
1176
1177         /* reset result */
1178         if((val[HWRST_RSLT] & VALID) == VALID_VAL)
1179         {
1180                 printf("HW reset results:\n");
1181                 if_else_printf((val[HWRST_RSLT] & CBLID),"\tCBLID- above Vih\n","\tCBLID- below Vih\n");
1182
1183                 if(val[HWRST_RSLT] & RST0)
1184                 {
1185                         printf("\tDevice num = 0");
1186                         jj = val[HWRST_RSLT];
1187                 }
1188                 else
1189                 {
1190                         printf("\tDevice num = 1");
1191                         jj = val[HWRST_RSLT] >> 8;
1192                 }
1193
1194                 if((jj & DEV_DET) == JUMPER_VAL)
1195                         printf(" determined by the jumper");
1196                 else if((jj & DEV_DET) == CSEL_VAL)
1197                         printf(" determined by CSEL");
1198                 printf("\n");
1199         }
1200
1201         /* more stuff from std 5 */
1202         if((like_std > 4) && (eqpt != CDROM))
1203         {
1204                 if(val[CFA_PWR_MODE] & VALID_W160)
1205                 {
1206                         printf("CFA power mode 1:\n\t");
1207                         if_else_printf((val[CFA_PWR_MODE] & PWR_MODE_OFF),"disabled","enabled");
1208
1209                         if_printf((val[CFA_PWR_MODE] & PWR_MODE_REQ)," and required by some commands");
1210                         printf("\n");
1211
1212                         if_printf((val[CFA_PWR_MODE] & MAX_AMPS),"\tMaximum current = %uma\n",val[CFA_PWR_MODE] & MAX_AMPS);
1213                 }
1214                 if((val[INTEGRITY] & SIG) == SIG_VAL)
1215                 {
1216                         printf("Checksum: ");
1217                         if_printf(chksum,"in");
1218                         printf("correct\n");
1219                 }
1220         }
1221
1222         exit(0);
1223 }
1224 #endif
1225
1226 static int verbose, get_identity, get_geom, noisy = 1, quiet;
1227 static int flagcount, do_flush, is_scsi_hd, is_xt_hd;
1228 static int do_ctimings, do_timings;
1229
1230 static unsigned long set_readahead, get_readahead, Xreadahead;
1231 static unsigned long set_readonly, get_readonly, readonly;
1232 static unsigned long set_unmask, get_unmask, unmask;
1233 static unsigned long set_mult, get_mult, mult;
1234 #ifdef CONFIG_FEATURE_HDPARM_HDIO_GETSET_DMA
1235 static unsigned long set_dma, get_dma, dma;
1236 #endif
1237 static unsigned long set_dma_q, get_dma_q, dma_q;
1238 static unsigned long set_nowerr, get_nowerr, nowerr;
1239 static unsigned long set_keep, get_keep, keep;
1240 static unsigned long set_io32bit, get_io32bit, io32bit;
1241 static unsigned long set_piomode, noisy_piomode;
1242 static int piomode;
1243 #ifdef HDIO_DRIVE_CMD
1244 static unsigned long set_dkeep, get_dkeep, dkeep;
1245 static unsigned long set_standby, get_standby, standby_requested;
1246 static unsigned long set_xfermode, get_xfermode;
1247 static int xfermode_requested;
1248 static unsigned long set_lookahead, get_lookahead, lookahead;
1249 static unsigned long set_prefetch, get_prefetch, prefetch;
1250 static unsigned long set_defects, get_defects, defects;
1251 static unsigned long set_wcache, get_wcache, wcache;
1252 static unsigned long set_doorlock, get_doorlock, doorlock;
1253 static unsigned long set_seagate, get_seagate;
1254 static unsigned long set_standbynow, get_standbynow;
1255 static unsigned long set_sleepnow, get_sleepnow;
1256 static unsigned long get_powermode;
1257 static unsigned long set_apmmode, get_apmmode, apmmode;
1258 #endif
1259 #ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY
1260 static int get_IDentity;
1261 #endif
1262 #ifdef CONFIG_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF
1263 static int      unregister_hwif;
1264 static int      hwif;
1265 #endif
1266 #ifdef CONFIG_FEATURE_HDPARM_HDIO_SCAN_HWIF
1267 static int      scan_hwif;
1268 static int      hwif_data;
1269 static int      hwif_ctrl;
1270 static int      hwif_irq;
1271 #endif
1272 #ifdef CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF
1273 static int      set_busstate, get_busstate, busstate;
1274 #endif
1275 static int      reread_partn;
1276
1277 #ifdef CONFIG_FEATURE_HDPARM_HDIO_DRIVE_RESET
1278 static int      perform_reset;
1279 #endif /* CONFIG_FEATURE_HDPARM_HDIO_DRIVE_RESET */
1280 #ifdef CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF
1281 static int      perform_tristate,       tristate;
1282 #endif /* CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF */
1283
1284 // Historically, if there was no HDIO_OBSOLETE_IDENTITY, then
1285 // then the HDIO_GET_IDENTITY only returned 142 bytes.
1286 // Otherwise, HDIO_OBSOLETE_IDENTITY returns 142 bytes,
1287 // and HDIO_GET_IDENTITY returns 512 bytes.  But the latest
1288 // 2.5.xx kernels no longer define HDIO_OBSOLETE_IDENTITY
1289 // (which they should, but they should just return -EINVAL).
1290 //
1291 // So.. we must now assume that HDIO_GET_IDENTITY returns 512 bytes.
1292 // On a really old system, it will not, and we will be confused.
1293 // Too bad, really.
1294
1295 #ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY
1296 static const char * const cfg_str[] =
1297 {       "",          " HardSect",   " SoftSect",  " NotMFM",
1298         " HdSw>15uSec", " SpinMotCtl", " Fixed",     " Removeable",
1299         " DTR<=5Mbs",   " DTR>5Mbs",   " DTR>10Mbs", " RotSpdTol>.5%",
1300         " dStbOff",     " TrkOff",     " FmtGapReq", " nonMagnetic"
1301 };
1302
1303 static const char * const BuffType[]    = {"unknown", "1Sect", "DualPort", "DualPortCache"};
1304
1305 static void dump_identity (const struct hd_driveid *id)
1306 {
1307         int i;
1308         char pmodes[64] = {0,}, dmodes[128]={0,}, umodes[128]={0,};
1309         const unsigned short int *id_regs= (const void*) id;
1310         unsigned long capacity;
1311
1312         printf("\n Model=%.40s, FwRev=%.8s, SerialNo=%.20s\n Config={",
1313                                 id->model, id->fw_rev, id->serial_no);
1314         for (i=0; i<=15; i++)
1315                 if_printf((id->config & (1<<i)),"%s", cfg_str[i]);
1316
1317         printf(" }\n RawCHS=%u/%u/%u, TrkSize=%u, SectSize=%u, ECCbytes=%u\n",
1318                                 id->cyls, id->heads, id->sectors, id->track_bytes,
1319                                 id->sector_bytes, id->ecc_bytes);
1320
1321         if (id->buf_type > 3)
1322                 printf("%s%u", " BuffType=", id->buf_type);
1323         else
1324                 printf("%s%s", " BuffType=", BuffType[id->buf_type]);
1325
1326         printf(", BuffSize=%ukB, MaxMultSect=%u", id->buf_size/2, id->max_multsect);
1327         if (id->max_multsect)
1328         {
1329                 printf(", MultSect=");
1330                 if (!(id->multsect_valid&1))
1331                         printf("?%u?", id->multsect);
1332                 else if (id->multsect)
1333                         printf("%u", id->multsect);
1334                 else
1335                         printf("off");
1336         }
1337         printf("\n");
1338         if (id->tPIO <= 5)
1339         {
1340                 strcat(pmodes, "pio0 ");
1341                 if_strcat((id->tPIO >= 1), pmodes, "pio1 ");
1342                 if_strcat((id->tPIO >= 2), pmodes, "pio2 ");
1343
1344         }
1345         if_printf((!(id->field_valid&1))," (maybe):");
1346 #if __BYTE_ORDER == __BIG_ENDIAN
1347         capacity = (id->cur_capacity0 << 16) | id->cur_capacity1;
1348 #else
1349         capacity = (id->cur_capacity1 << 16) | id->cur_capacity0;
1350 #endif
1351         printf(" CurCHS=%u/%u/%u, CurSects=%lu, LBA=%s",id->cur_cyls, id->cur_heads,
1352                                                                                                         id->cur_sectors, capacity ,
1353                                                                                         ((id->capability&2)==0)?"no":"yes");
1354
1355         if_printf((id->capability&2),", LBAsects=%u", id->lba_capacity);
1356
1357         if (id->capability&1)
1358         {
1359                 if (id->dma_1word | id->dma_mword)
1360                 {
1361                         if_strcat((id->dma_1word & 0x100),      dmodes, "*");
1362                         if_strcat((id->dma_1word & 1),          dmodes, "sdma0 ");
1363                         if_strcat((id->dma_1word & 0x200),      dmodes, "*");
1364                         if_strcat((id->dma_1word & 2),          dmodes, "sdma1 ");
1365                         if_strcat((id->dma_1word & 0x400),      dmodes, "*");
1366                         if_strcat((id->dma_1word & 4),          dmodes, "sdma2 ");
1367                         if_strcat((id->dma_1word & 0xf800),     dmodes, "*");
1368                         if_strcat((id->dma_1word & 0xf8),       dmodes, "sdma? ");
1369                         if_strcat((id->dma_mword & 0x100),      dmodes, "*");
1370                         if_strcat((id->dma_mword & 1),          dmodes, "mdma0 ");
1371                         if_strcat((id->dma_mword & 0x200),      dmodes, "*");
1372                         if_strcat((id->dma_mword & 2),          dmodes, "mdma1 ");
1373                         if_strcat((id->dma_mword & 0x400),      dmodes, "*");
1374                         if_strcat((id->dma_mword & 4),          dmodes, "mdma2 ");
1375                         if_strcat((id->dma_mword & 0xf800),     dmodes, "*");
1376                         if_strcat((id->dma_mword & 0xf8),       dmodes, "mdma? ");
1377                 }
1378         }
1379         printf("\n IORDY=");
1380         if (id->capability&8)
1381                 printf((id->capability&4) ? "on/off" : "yes");
1382         else
1383                 printf("no");
1384
1385         if ((id->capability&8) || (id->field_valid&2))
1386         {
1387                 if (id->field_valid&2)
1388                 {
1389                         printf(", tPIO={min:%u,w/IORDY:%u}", id->eide_pio, id->eide_pio_iordy);
1390                         if_strcat((id->eide_pio_modes & 1), pmodes, "pio3 ");
1391                         if_strcat((id->eide_pio_modes & 2), pmodes, "pio4 ");
1392                         if_strcat((id->eide_pio_modes &~3), pmodes, "pio? ");
1393                 }
1394                 if (id->field_valid&4)
1395                 {
1396                         if_strcat((id->dma_ultra & 0x100),umodes,"*");
1397                         if_strcat((id->dma_ultra & 0x001),umodes,"udma0 ");
1398                         if_strcat((id->dma_ultra & 0x200),umodes,"*");
1399                         if_strcat((id->dma_ultra & 0x002),umodes,"udma1 ");
1400                         if_strcat((id->dma_ultra & 0x400),umodes,"*");
1401                         if_strcat((id->dma_ultra & 0x004),umodes,"udma2 ");
1402 #ifdef __NEW_HD_DRIVE_ID
1403                         if (id->hw_config & 0x2000)
1404                         {
1405 #else /* !__NEW_HD_DRIVE_ID */
1406                         if (id->word93 & 0x2000)
1407                         {
1408 #endif /* __NEW_HD_DRIVE_ID */
1409                                 if_strcat((id->dma_ultra & 0x0800),umodes,"*");
1410                                 if_strcat((id->dma_ultra & 0x0008),umodes,"udma3 ");
1411                                 if_strcat((id->dma_ultra & 0x1000),umodes,"*");
1412                                 if_strcat((id->dma_ultra & 0x0010),umodes,"udma4 ");
1413                                 if_strcat((id->dma_ultra & 0x2000),umodes,"*");
1414                                 if_strcat((id->dma_ultra & 0x0020),umodes,"udma5 ");
1415                                 if_strcat((id->dma_ultra & 0x4000),umodes,"*");
1416                                 if_strcat((id->dma_ultra & 0x0040),umodes,"udma6 ");
1417                                 if_strcat((id->dma_ultra & 0x8000),umodes,"*");
1418                                 if_strcat((id->dma_ultra & 0x0080),umodes,"udma7 ");
1419                         }
1420                 }
1421         }
1422         if_printf(((id->capability&1) && (id->field_valid&2)),
1423                                 ", tDMA={min:%u,rec:%u}", id->eide_dma_min, id->eide_dma_time);
1424         printf("\n PIO modes:  %s", pmodes);
1425         if_printf((*dmodes),"\n DMA modes:  %s", dmodes);
1426         if_printf((*umodes),"\n UDMA modes: %s", umodes);
1427
1428         printf("\n AdvancedPM=%s",((id_regs[83]&8)==0)?"no":"yes");
1429         if (id_regs[83] & 8)
1430         {
1431                 if (!(id_regs[86]&8))
1432                         printf(": disabled (255)");
1433                 else if ((id_regs[91]&0xFF00)!=0x4000)
1434                         printf(": unknown setting");
1435                 else
1436                         printf(": mode=0x%02X (%u)",id_regs[91]&0xFF,id_regs[91]&0xFF);
1437         }
1438         if_printf( (id_regs[82]&0x20)," WriteCache=%s",(id_regs[85]&0x20) ? "enabled" : "disabled");
1439 #ifdef __NEW_HD_DRIVE_ID
1440         if ((id->minor_rev_num && id->minor_rev_num <= 31) || (id->major_rev_num && id->minor_rev_num <= 31))
1441         {
1442                 printf("\n Drive conforms to: ");
1443                 if_else_printf((id->minor_rev_num <= 31),"%s: ","unknown: ", minor_str[id->minor_rev_num]);
1444                 if (id->major_rev_num < 31)
1445                 {
1446                         for (i=0; i <= 15; i++)
1447                                 if_printf((id->major_rev_num & (1<<i))," %u", i);
1448                 }
1449         }
1450 #endif /* __NEW_HD_DRIVE_ID */
1451         printf("\n\n * signifies the current active mode\n\n");
1452 }
1453 #endif
1454
1455 static void flush_buffer_cache (int fd)
1456 {
1457         fsync (fd);                             /* flush buffers */
1458         bb_ioctl(fd, BLKFLSBUF, NULL,"BLKFLSBUF" ) ;/* do it again, big time */
1459 #ifdef HDIO_DRIVE_CMD
1460         sleep(1);
1461         if (ioctl(fd, HDIO_DRIVE_CMD, NULL) && errno != EINVAL) /* await completion */
1462                         bb_perror_msg("HDIO_DRIVE_CMD");
1463 #endif
1464 }
1465
1466 static int seek_to_zero (int fd)
1467 {
1468         if (lseek(fd, (off_t) 0, SEEK_SET))
1469                 return 1;
1470         return 0;
1471 }
1472
1473 static int read_big_block (int fd, char *buf)
1474 {
1475
1476         const char *string;
1477         int i, rc;
1478         if ((rc = read(fd, buf, TIMING_BUF_BYTES)) != TIMING_BUF_BYTES)
1479         {
1480                 switch(rc)
1481                 {
1482                         case -1:
1483                                 string = "read()";
1484                                 break;
1485                         case  0:
1486                                 string = "read() hit EOF - device too small";
1487                                 break;
1488                         default:
1489                                 string = "read(%u) returned %u bytes";
1490                 }
1491                 bb_error_msg(string, TIMING_BUF_BYTES, rc);
1492                 return 1;
1493         }
1494
1495         /* access all sectors of buf to ensure the read fully completed */
1496         for (i = 0; i < TIMING_BUF_BYTES; i += 512)
1497                 buf[i] &= 1;
1498         return 0;
1499 }
1500
1501 static double correction;
1502
1503 static void do_time (int flag, int fd)
1504 /*
1505         flag = 0 time_cache
1506         flag = 1 time_device
1507 */
1508 {
1509         int i;
1510         char *buf;
1511         double elapsed;
1512         struct itimerval e1, e2;
1513         int shmid;
1514         int timing_MB = TIMING_MB;
1515
1516         if ((shmid = shmget(IPC_PRIVATE, TIMING_BUF_BYTES, 0600)) == -1)
1517         {
1518                 bb_error_msg (bb_msg_shared_mem,"allocate"); /*"could not allocate sharedmem buf"*/
1519                 return;
1520         }
1521         if (shmctl(shmid, SHM_LOCK, NULL) == -1)
1522         {
1523                 bb_error_msg (bb_msg_shared_mem,"lock"); /*"could not lock sharedmem buf"*/
1524                 (void) shmctl(shmid, IPC_RMID, NULL);
1525                 return;
1526         }
1527         if ((buf = shmat(shmid, (char *) 0, 0)) == (char *) -1)
1528         {
1529                 bb_error_msg (bb_msg_shared_mem,"attach"); /*"could not attach sharedmem buf"*/
1530                 (void) shmctl(shmid, IPC_RMID, NULL);
1531                 return;
1532         }
1533         if (shmctl(shmid, IPC_RMID, NULL) == -1)
1534                 bb_error_msg ("shmctl(,IPC_RMID,)");
1535
1536         /* Clear out the device request queues & give them time to complete */
1537         sync_and_sleep(3);
1538
1539         if(flag  == 0) /* Time cache */
1540         {
1541                 /* Calculate a correction factor for the basic
1542                 * overhead of doing a read() from the buffer cache.
1543                 * To do this, we read the data once to "cache it" and
1544                 * to force full preallocation of our timing buffer,
1545                 * and then we re-read it 10 times while timing it.
1546                 *
1547                 * getitimer() is used rather than gettimeofday() because
1548                 * it is much more consistent (on my machine, at least).
1549                 */
1550                 setitimer(ITIMER_REAL, &(struct itimerval){{1000,0},{1000,0}}, NULL);
1551                 if (seek_to_zero (fd))
1552                         return;
1553                 if (read_big_block (fd, buf))
1554                         return;
1555                 printf(" Timing buffer-cache reads:   ");
1556                 fflush(stdout);
1557
1558                 /* Clear out the device request queues & give them time to complete */
1559                 sync_and_sleep(1);
1560
1561                 /* Time re-reading from the buffer-cache */
1562                 getitimer(ITIMER_REAL, &e1);
1563                 for (i = (BUFCACHE_FACTOR * TIMING_BUF_COUNT) ; i > 0; --i)
1564                 {
1565                         if (seek_to_zero (fd))
1566                                 goto quit;
1567                         if (read_big_block (fd, buf))
1568                                 goto quit;
1569                 }
1570                 getitimer(ITIMER_REAL, &e2);
1571                 correction = (e1.it_value.tv_sec - e2.it_value.tv_sec) + ((e1.it_value.tv_usec - e2.it_value.tv_usec) / 1000000.0);
1572
1573                 /* Now remove the lseek() from the correction factor */
1574                 getitimer(ITIMER_REAL, &e1);
1575                 for (i = (BUFCACHE_FACTOR * TIMING_BUF_COUNT) ; i > 0; --i)
1576                 {
1577                         if (seek_to_zero (fd))
1578                                 goto quit;
1579                 }
1580                 getitimer(ITIMER_REAL, &e2);
1581                 correction -= (e1.it_value.tv_sec - e2.it_value.tv_sec)
1582                 + ((e1.it_value.tv_usec - e2.it_value.tv_usec) / 1000000.0);
1583
1584                 if ((BUFCACHE_FACTOR * timing_MB) >= correction)  /* more than 1MB/s */
1585                         printf("%2d MB in %5.2f seconds =%6.2f MB/sec\n",
1586                                 (BUFCACHE_FACTOR * timing_MB),  correction,
1587                                 (BUFCACHE_FACTOR * timing_MB) / correction);
1588                 else
1589                         printf("%2d MB in %5.2f seconds =%6.2f kB/sec\n",
1590                                 (BUFCACHE_FACTOR * timing_MB),  correction,
1591                                 (BUFCACHE_FACTOR * timing_MB) / correction * 1024);
1592                 correction /= BUFCACHE_FACTOR;
1593
1594                 flush_buffer_cache(fd);
1595                 sleep(1);
1596         }
1597         else /* Time device */
1598         {
1599                 printf(" Timing buffered disk reads:  ");
1600                 fflush(stdout);
1601
1602                 /*
1603                 * getitimer() is used rather than gettimeofday() because
1604                 * it is much more consistent (on my machine, at least).
1605                 */
1606                 setitimer(ITIMER_REAL, &(struct itimerval){{1000,0},{1000,0}}, NULL);
1607
1608                 /* Now do the timings for real */
1609                 getitimer(ITIMER_REAL, &e1);
1610                 for (i = TIMING_BUF_COUNT; i > 0; --i)
1611                 {
1612                         if (read_big_block (fd, buf))
1613                                 goto quit;
1614                 }
1615                 getitimer(ITIMER_REAL, &e2);
1616
1617                 elapsed =       (e1.it_value.tv_sec - e2.it_value.tv_sec) + ((e1.it_value.tv_usec - e2.it_value.tv_usec) / 1000000.0);
1618
1619                 if (timing_MB >= elapsed)  /* more than 1MB/s */
1620                         printf("%2d MB in %5.2f seconds =%6.2f MB/sec\n",timing_MB, elapsed, timing_MB / elapsed);
1621                 else
1622                         printf("%2d MB in %5.2f seconds =%6.2f kB/sec\n",timing_MB, elapsed, timing_MB / elapsed * 1024);
1623
1624                 /*"Hmm.. suspicious results: probably not enough free memory for a proper test.");*/
1625                 if (elapsed <= (correction * 2))
1626                                         bb_error_msg(bb_msg_memory_exhausted);
1627
1628 #if 0  /* the "estimate" is just plain wrong for many systems.. */
1629                 else if (correction != 0.0) {
1630                         printf(" Estimating raw driver speed: ");
1631                         elapsed -= correction;
1632                         if (timing_MB >= elapsed)  /* more than 1MB/s */
1633                                 printf("%2d MB in %5.2f seconds =%6.2f MB/sec\n",
1634                                         timing_MB, elapsed, timing_MB / elapsed);
1635                         else
1636                                 printf("%2d MB in %5.2f seconds =%6.2f kB/sec\n",
1637                                         timing_MB, elapsed, timing_MB / elapsed * 1024);
1638                 }
1639 #endif
1640         }
1641 quit:
1642         if (-1 == shmdt(buf))
1643                 bb_error_msg (bb_msg_shared_mem,"detach"); /*"could not detach sharedmem buf"*/
1644 }
1645
1646
1647 static void no_scsi (void)
1648 {
1649         /*" operation not supported on SCSI disks"*/
1650         if (is_scsi_hd)
1651                 bb_error_msg_and_die(bb_msg_op_not_supp,"SCSI");
1652 }
1653
1654 static void no_xt (void)
1655 {
1656         if (is_xt_hd)
1657                 bb_error_msg_and_die(bb_msg_op_not_supp,"XT");
1658 }
1659
1660 static void on_off (unsigned int value)
1661 {
1662         printf(value ? " (on)\n" : " (off)\n");
1663 }
1664
1665 #ifdef CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF
1666 static void bus_state_value (unsigned int value)
1667 {
1668         const char *string;
1669
1670         switch (value)
1671         {
1672                 case BUSSTATE_ON:
1673                         string = " (on)\n";
1674                         break;
1675                 case BUSSTATE_OFF:
1676                         string = " (off)\n";
1677                         break;
1678                 case BUSSTATE_TRISTATE:
1679                         string = " (tristate)\n";
1680                         break;
1681                 default:
1682                         string = " (unknown: %d)\n";
1683                         break;
1684         }
1685         printf(string, value);
1686 }
1687 #endif
1688
1689 #ifdef HDIO_DRIVE_CMD
1690 static void interpret_standby (unsigned int standby)
1691 {
1692         printf(" (");
1693         switch(standby)
1694         {
1695                 case 0:
1696                         printf("off");
1697                         break;
1698                 case 252:
1699                         printf("21 minutes");
1700                         break;
1701                 case 253:
1702                         printf("vendor-specific");
1703                         break;
1704                 case 254:
1705                         printf("?reserved");
1706                         break;
1707                 case 255:
1708                         printf("21 minutes + 15 seconds");
1709                         break;
1710                 default:
1711                         if (standby <= 240)
1712                         {
1713                                 unsigned int secs = standby * 5;
1714                                 unsigned int mins = secs / 60;
1715                                 secs %= 60;
1716                                 if_printf(mins,"%u minutes", mins);
1717                                 if_printf((mins && secs)," + ");
1718                                 if_printf(secs,"%u seconds", secs);
1719                         }
1720                         else if (standby <= 251)
1721                         {
1722                                 unsigned int mins = (standby - 240) * 30;
1723                                 unsigned int hrs  = mins / 60;
1724                                 mins %= 60;
1725                                 if_printf(hrs,"%u hours", hrs);
1726                                 if_printf((hrs && mins)," + ");
1727                                 if_printf(mins,"%u minutes", mins);
1728                         }
1729                         else
1730                                 printf("illegal value");
1731                         break;
1732         }
1733         printf(")\n");
1734 }
1735
1736 struct xfermode_entry {
1737     int val;
1738     const char *name;
1739 };
1740
1741 static const struct xfermode_entry xfermode_table[] = {
1742     { 8,    "pio0" },
1743     { 9,    "pio1" },
1744     { 10,   "pio2" },
1745     { 11,   "pio3" },
1746     { 12,   "pio4" },
1747     { 13,   "pio5" },
1748     { 14,   "pio6" },
1749     { 15,   "pio7" },
1750     { 16,   "sdma0" },
1751     { 17,   "sdma1" },
1752     { 18,   "sdma2" },
1753     { 19,   "sdma3" },
1754     { 20,   "sdma4" },
1755     { 21,   "sdma5" },
1756     { 22,   "sdma6" },
1757     { 23,   "sdma7" },
1758     { 32,   "mdma0" },
1759     { 33,   "mdma1" },
1760     { 34,   "mdma2" },
1761     { 35,   "mdma3" },
1762     { 36,   "mdma4" },
1763     { 37,   "mdma5" },
1764     { 38,   "mdma6" },
1765     { 39,   "mdma7" },
1766     { 64,   "udma0" },
1767     { 65,   "udma1" },
1768     { 66,   "udma2" },
1769     { 67,   "udma3" },
1770     { 68,   "udma4" },
1771     { 69,   "udma5" },
1772     { 70,   "udma6" },
1773     { 71,   "udma7" },
1774     { 0, NULL }
1775 };
1776
1777 static int translate_xfermode(char * name)
1778 {
1779         const struct xfermode_entry *tmp;
1780         char *endptr;
1781         int val = -1;
1782
1783
1784         for (tmp = xfermode_table; tmp->name != NULL; ++tmp)
1785         {
1786                 if (!strcmp(name, tmp->name))
1787                         return tmp->val;
1788
1789         }
1790
1791         val = strtol(name, &endptr, 10);
1792         if (*endptr == '\0')
1793                 return val;
1794
1795         return -1;
1796 }
1797
1798 static void interpret_xfermode (unsigned int xfermode)
1799 {
1800         printf(" (");
1801         switch(xfermode) {
1802                 case 0:
1803                         printf("default PIO mode");
1804                         break;
1805                 case 1:
1806                         printf("default PIO mode, disable IORDY");
1807                         break;
1808                 case 8:
1809                 case 9:
1810                 case 10:
1811                 case 11:
1812                 case 12:
1813                 case 13:
1814                 case 14:
1815                 case 15:
1816                         printf("PIO flow control mode%u", xfermode-8);
1817                         break;
1818                 case 16:
1819                 case 17:
1820                 case 18:
1821                 case 19:
1822                 case 20:
1823                 case 21:
1824                 case 22:
1825                 case 23:
1826                         printf("singleword DMA mode%u", xfermode-16);
1827                         break;
1828                 case 32:
1829                 case 33:
1830                 case 34:
1831                 case 35:
1832                 case 36:
1833                 case 37:
1834                 case 38:
1835                 case 39:
1836                         printf("multiword DMA mode%u", xfermode-32);
1837                         break;
1838                 case 64:
1839                 case 65:
1840                 case 66:
1841                 case 67:
1842                 case 68:
1843                 case 69:
1844                 case 70:
1845                 case 71:
1846                         printf("UltraDMA mode%u", xfermode-64);
1847                         break;
1848                 default:
1849                         printf("unknown, probably not valid");
1850                         break;
1851         }
1852         printf(")\n");
1853 }
1854 #endif /* HDIO_DRIVE_CMD */
1855
1856 #ifndef VXVM_MAJOR
1857 #define VXVM_MAJOR 199
1858 #endif
1859
1860 #ifndef CCISS_MAJOR
1861 #define CCISS_MAJOR 104
1862 #endif
1863
1864 static void process_dev (char *devname)
1865 {
1866         int fd;
1867         static long parm, multcount;
1868         struct stat stat_buf;
1869 #ifndef HDIO_DRIVE_CMD
1870         int force_operation = 0;
1871 #endif
1872         if (stat(devname,&stat_buf))
1873                 bb_perror_msg_and_die(devname);
1874
1875         switch(major(stat_buf.st_rdev))
1876         {
1877 #ifdef SCSI_DISK0_MAJOR
1878                 case (SCSI_DISK0_MAJOR):
1879                 case (SCSI_DISK1_MAJOR):
1880                 case (SCSI_DISK2_MAJOR):
1881                 case (SCSI_DISK3_MAJOR):
1882                 case (SCSI_DISK4_MAJOR):
1883                 case (SCSI_DISK5_MAJOR):
1884                 case (SCSI_DISK6_MAJOR):
1885                 case (SCSI_DISK7_MAJOR):
1886 #else
1887                 case (SCSI_DISK_MAJOR):
1888 #endif
1889 #ifdef MD_MAJOR
1890                 case (MD_MAJOR):
1891 #endif
1892                 case (VXVM_MAJOR):
1893 #ifdef LVM_BLK_MAJOR
1894                 case (LVM_BLK_MAJOR):
1895 #endif
1896                 case (CCISS_MAJOR):
1897                         is_scsi_hd = 1;
1898                         break;
1899 #ifdef XT_DISK_MAJOR
1900                 case (XT_DISK_MAJOR):
1901                         is_xt_hd = 1;
1902                         break;
1903 #endif
1904                 case IDE0_MAJOR:
1905                 case IDE1_MAJOR:
1906 #ifdef IDE2_MAJOR
1907                 case IDE2_MAJOR:
1908 #endif
1909 #ifdef IDE3_MAJOR
1910                 case IDE3_MAJOR:
1911 #endif
1912 #ifdef IDE4_MAJOR
1913                 case IDE4_MAJOR:
1914 #endif
1915 #ifdef IDE5_MAJOR
1916                 case IDE5_MAJOR:
1917 #endif
1918 #ifdef IDE6_MAJOR
1919                 case IDE6_MAJOR:
1920 #endif
1921 #ifdef IDE7_MAJOR
1922                 case IDE7_MAJOR:
1923 #endif
1924 #ifdef IDE8_MAJOR
1925                 case IDE8_MAJOR:
1926 #endif
1927 #ifdef IDE9_MAJOR
1928                 case IDE9_MAJOR:
1929 #endif
1930                         break;  /* do nothing */
1931                 default:
1932                         bb_error_msg_and_die("%s not supported",devname);
1933         }
1934
1935         fd = bb_xopen (devname, O_RDONLY|O_NONBLOCK);
1936         if_printf( (!quiet),"\n%s:\n", devname);
1937
1938         if (set_readahead)
1939         {
1940                 if_printf(get_readahead," setting fs readahead to %ld\n", Xreadahead);
1941                 bb_ioctl(fd, BLKRASET,(int *)Xreadahead,"BLKRASET");
1942         }
1943 #ifdef CONFIG_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF
1944         if (unregister_hwif)
1945         {
1946                 no_scsi();
1947                 printf(" attempting to unregister hwif#%u\n", hwif);
1948                 bb_ioctl(fd, HDIO_UNREGISTER_HWIF,(int *)hwif,"HDIO_UNREGISTER_HWIF");
1949         }
1950 #endif
1951 #ifdef CONFIG_FEATURE_HDPARM_HDIO_SCAN_HWIF
1952         if (scan_hwif)
1953         {
1954                 int     args[3];
1955                 no_scsi();
1956                 printf(" attempting to scan hwif (0x%x, 0x%x, %u)\n", hwif_data, hwif_ctrl, hwif_irq);
1957                 args[0] = hwif_data;
1958                 args[1] = hwif_ctrl;
1959                 args[2] = hwif_irq;
1960                 bb_ioctl(fd, HDIO_SCAN_HWIF, args, "HDIO_SCAN_HWIF");
1961         }
1962 #endif
1963         if (set_piomode)
1964         {
1965                 no_scsi();
1966                 no_xt();
1967
1968                 if (noisy_piomode)
1969                 {
1970                         printf(" attempting to ");
1971                         if (piomode == 255)
1972                                 printf("auto-tune PIO mode\n");
1973                         else if (piomode < 100)
1974                                 printf("set PIO mode to %d\n", piomode);
1975                         else if (piomode < 200)
1976                                 printf("set MDMA mode to %d\n", (piomode-100));
1977                         else
1978                                 printf("set UDMA mode to %d\n", (piomode-200));
1979                 }
1980                 bb_ioctl(fd, HDIO_SET_PIO_MODE, (int *)piomode, "HDIO_SET_PIO_MODE");
1981         }
1982         if (set_io32bit)
1983         {
1984                 no_scsi();
1985                 no_xt();
1986                 if_printf(get_io32bit," setting 32-bit IO_support flag to %ld\n", io32bit);
1987                 bb_ioctl(fd, HDIO_SET_32BIT, (int *)io32bit, "HDIO_SET_32BIT");
1988         }
1989         if (set_mult)
1990         {
1991                 no_scsi();
1992                 no_xt();
1993                 if_printf(get_mult, " setting multcount to %ld\n", mult);
1994                 if(ioctl(fd, HDIO_SET_MULTCOUNT, mult))
1995                         bb_perror_msg("HDIO_SET_MULTCOUNT");
1996 #ifndef HDIO_DRIVE_CMD
1997                 else
1998                         force_operation = 1;
1999 #endif
2000         }
2001         if (set_readonly)
2002         {
2003                 if_printf_on_off(get_readonly," setting readonly to %ld", readonly);
2004                 bb_ioctl(fd, BLKROSET, &readonly, "BLKROSET");
2005         }
2006         if (set_unmask)
2007         {
2008                 no_scsi();
2009                 no_xt();
2010                 if_printf_on_off(get_unmask," setting unmaskirq to %ld", unmask);
2011                 bb_ioctl(fd, HDIO_SET_UNMASKINTR, (int *)unmask, "HDIO_SET_UNMASKINTR");
2012         }
2013 #ifdef CONFIG_FEATURE_HDPARM_HDIO_GETSET_DMA
2014         if (set_dma)
2015         {
2016                 no_scsi();
2017                 if_printf_on_off(get_dma," setting using_dma to %ld", dma);
2018                 bb_ioctl(fd, HDIO_SET_DMA, (int *)dma, "HDIO_SET_DMA");
2019         }
2020 #endif /* CONFIG_FEATURE_HDPARM_HDIO_GETSET_DMA */
2021         if (set_dma_q)
2022         {
2023                 no_scsi();
2024                 if_printf_on_off(get_dma_q," setting DMA queue_depth to %ld", dma_q);
2025                 bb_ioctl(fd, HDIO_SET_QDMA, (int *)dma_q, "HDIO_SET_QDMA");
2026         }
2027         if (set_nowerr)
2028         {
2029                 no_scsi();
2030                 no_xt();
2031                 if_printf_on_off(get_nowerr," setting nowerr to %ld", nowerr);
2032                 bb_ioctl(fd, HDIO_SET_NOWERR, (int *)nowerr,"HDIO_SET_NOWERR");
2033         }
2034         if (set_keep)
2035         {
2036                 no_scsi();
2037                 no_xt();
2038                 if_printf_on_off(get_keep," setting keep_settings to %ld", keep);
2039                 bb_ioctl(fd, HDIO_SET_KEEPSETTINGS, (int *)keep,"HDIO_SET_KEEPSETTINGS");
2040         }
2041 #ifdef HDIO_DRIVE_CMD
2042         if (set_doorlock)
2043         {
2044                 unsigned char args[4] = {0,0,0,0};
2045                 no_scsi();
2046                 no_xt();
2047
2048                 args[0] = doorlock ? WIN_DOORLOCK : WIN_DOORUNLOCK;
2049                 if_printf_on_off(get_doorlock," setting drive doorlock to %ld", doorlock);
2050                 bb_ioctl(fd, HDIO_DRIVE_CMD, &args,"HDIO_DRIVE_CMD(doorlock)");
2051         }
2052         if (set_dkeep)
2053         {
2054                 /* lock/unlock the drive's "feature" settings */
2055                 unsigned char args[4] = {WIN_SETFEATURES,0,0,0};
2056                 no_scsi();
2057                 no_xt();
2058
2059                 if_printf_on_off(get_dkeep," setting drive keep features to %ld", dkeep);
2060                 args[2] = dkeep ? 0x66 : 0xcc;
2061                 bb_ioctl(fd, HDIO_DRIVE_CMD, &args,"HDIO_DRIVE_CMD(keepsettings)");
2062         }
2063         if (set_defects)
2064         {
2065                 unsigned char args[4] = {WIN_SETFEATURES,0,0x04,0};
2066                 no_scsi();
2067                 args[2] = defects ? 0x04 : 0x84;
2068                 if_printf(get_defects," setting drive defect-mgmt to %ld\n", defects);
2069                 bb_ioctl(fd, HDIO_DRIVE_CMD, &args,"HDIO_DRIVE_CMD(defectmgmt)");
2070         }
2071         if (set_prefetch)
2072         {
2073                 unsigned char args[4] = {WIN_SETFEATURES,0,0xab,0};
2074                 no_scsi();
2075                 no_xt();
2076
2077                 args[1] = prefetch;
2078                 if_printf(get_prefetch," setting drive prefetch to %ld\n", prefetch);
2079                 bb_ioctl(fd, HDIO_DRIVE_CMD, &args, "HDIO_DRIVE_CMD(setprefetch)");
2080         }
2081         if (set_xfermode)
2082         {
2083                 unsigned char args[4] = {WIN_SETFEATURES,0,3,0};
2084                 no_scsi();
2085                 no_xt();
2086
2087                 args[1] = xfermode_requested;
2088                 if (get_xfermode)
2089                 {
2090                         printf(" setting xfermode to %d", xfermode_requested);
2091                         interpret_xfermode(xfermode_requested);
2092                 }
2093                 bb_ioctl(fd, HDIO_DRIVE_CMD, &args,"HDIO_DRIVE_CMD(setxfermode)");
2094         }
2095         if (set_lookahead)
2096         {
2097                 unsigned char args[4] = {WIN_SETFEATURES,0,0,0};
2098                 no_scsi();
2099                 no_xt();
2100
2101                 args[2] = lookahead ? 0xaa : 0x55;
2102                 if_printf_on_off(get_lookahead," setting drive read-lookahead to %ld", lookahead);
2103                 bb_ioctl(fd, HDIO_DRIVE_CMD, &args, "HDIO_DRIVE_CMD(setreadahead)");
2104         }
2105         if (set_apmmode)
2106         {
2107                 unsigned char args[4] = {WIN_SETFEATURES,0,0,0};
2108                 no_scsi();
2109                 apmmode=check_if_min_and_set_val(apmmode,1);
2110                 apmmode=check_if_maj_and_set_val(apmmode,255);
2111                 if_printf(get_apmmode," setting APM level to");
2112                 if (apmmode==255)
2113                 {
2114                         /* disable Advanced Power Management */
2115                         args[2] = 0x85; /* feature register */
2116                         if_printf(get_apmmode," disabled\n");
2117                 }
2118                 else
2119                 {
2120                         /* set Advanced Power Management mode */
2121                         args[2] = 0x05; /* feature register */
2122                         args[1] = apmmode; /* sector count register */
2123                         if_printf(get_apmmode," 0x%02lX (%ld)\n",apmmode,apmmode);
2124                 }
2125                 bb_ioctl(fd, HDIO_DRIVE_CMD, &args,"HDIO_DRIVE_CMD");
2126         }
2127         if (set_wcache)
2128         {
2129 #ifdef DO_FLUSHCACHE
2130 #ifndef WIN_FLUSHCACHE
2131 #define WIN_FLUSHCACHE 0xe7
2132 #endif
2133                 unsigned char flushcache[4] = {WIN_FLUSHCACHE,0,0,0};
2134 #endif /* DO_FLUSHCACHE */
2135                 unsigned char args[4] = {WIN_SETFEATURES,0,0,0};
2136                 no_scsi();
2137                 no_xt();
2138                 args[2] = wcache ? 0x02 : 0x82;
2139                 if_printf_on_off(get_wcache," setting drive write-caching to %ld", wcache);
2140 #ifdef DO_FLUSHCACHE
2141                 if (!wcache && ioctl(fd, HDIO_DRIVE_CMD, &flushcache))
2142                         bb_perror_msg ("HDIO_DRIVE_CMD(flushcache)");
2143 #endif /* DO_FLUSHCACHE */
2144                 bb_ioctl(fd, HDIO_DRIVE_CMD, &args, "HDIO_DRIVE_CMD(setcache)");
2145 #ifdef DO_FLUSHCACHE
2146                 if (!wcache && ioctl(fd, HDIO_DRIVE_CMD, &flushcache))
2147                         bb_perror_msg ("HDIO_DRIVE_CMD(flushcache)");
2148 #endif /* DO_FLUSHCACHE */
2149         }
2150         if (set_standbynow)
2151         {
2152 #ifndef WIN_STANDBYNOW1
2153 #define WIN_STANDBYNOW1 0xE0
2154 #endif
2155 #ifndef WIN_STANDBYNOW2
2156 #define WIN_STANDBYNOW2 0x94
2157 #endif
2158                 unsigned char args1[4] = {WIN_STANDBYNOW1,0,0,0};
2159                 unsigned char args2[4] = {WIN_STANDBYNOW2,0,0,0};
2160                 no_scsi();
2161                 if_printf(get_standbynow," issuing standby command\n");
2162                 if (ioctl(fd, HDIO_DRIVE_CMD, &args1)
2163                  && ioctl(fd, HDIO_DRIVE_CMD, &args2))
2164                         bb_perror_msg("HDIO_DRIVE_CMD(standby)");
2165         }
2166         if (set_sleepnow)
2167         {
2168 #ifndef WIN_SLEEPNOW1
2169 #define WIN_SLEEPNOW1 0xE6
2170 #endif
2171 #ifndef WIN_SLEEPNOW2
2172 #define WIN_SLEEPNOW2 0x99
2173 #endif
2174                 unsigned char args1[4] = {WIN_SLEEPNOW1,0,0,0};
2175                 unsigned char args2[4] = {WIN_SLEEPNOW2,0,0,0};
2176                 no_scsi();
2177                 if_printf(get_sleepnow," issuing sleep command\n");
2178                 if (ioctl(fd, HDIO_DRIVE_CMD, &args1)
2179                  && ioctl(fd, HDIO_DRIVE_CMD, &args2))
2180                         bb_perror_msg("HDIO_DRIVE_CMD(sleep)");
2181         }
2182         if (set_seagate)
2183         {
2184                 unsigned char args[4] = {0xfb,0,0,0};
2185                 no_scsi();
2186                 no_xt();
2187                 if_printf(get_seagate," disabling Seagate auto powersaving mode\n");
2188                 bb_ioctl(fd, HDIO_DRIVE_CMD, &args, "HDIO_DRIVE_CMD(seagatepwrsave)");
2189         }
2190         if (set_standby)
2191         {
2192                 unsigned char args[4] = {WIN_SETIDLE1,standby_requested,0,0};
2193                 no_scsi();
2194                 no_xt();
2195                 if (get_standby)
2196                 {
2197                         printf(" setting standby to %lu", standby_requested);
2198                         interpret_standby(standby_requested);
2199                 }
2200                 bb_ioctl(fd, HDIO_DRIVE_CMD, &args, "HDIO_DRIVE_CMD(setidle1)");
2201         }
2202 #else   /* HDIO_DRIVE_CMD */
2203         if (force_operation)
2204         {
2205                 char buf[512];
2206                 flush_buffer_cache(fd);
2207                 if (-1 == read(fd, buf, sizeof(buf)))
2208                         bb_error_msg("access failed");
2209         }
2210 #endif  /* HDIO_DRIVE_CMD */
2211
2212         if (!flagcount)
2213                 verbose = 1;
2214
2215         if ((verbose && !is_scsi_hd && !is_xt_hd) || get_mult || get_identity)
2216         {
2217                 no_scsi();
2218                 multcount = -1;
2219                 if (ioctl(fd, HDIO_GET_MULTCOUNT, &multcount))
2220                 {
2221                         if ((verbose && !is_xt_hd) || get_mult)
2222                                 bb_perror_msg("HDIO_GET_MULTCOUNT");
2223                 }
2224                 else if (verbose | get_mult)
2225                 {
2226                         printf(" multcount    = %2ld", multcount);
2227                         on_off(multcount);
2228                 }
2229         }
2230         if ((verbose && !is_scsi_hd && !is_xt_hd) || get_io32bit)
2231         {
2232                 no_scsi();
2233                 no_xt();
2234                 if(ioctl(fd, HDIO_GET_32BIT, &parm))
2235                         bb_perror_msg("HDIO_GET_32BIT");
2236                 else
2237                 {
2238                         printf(" IO_support   =%3ld (", parm);
2239                         switch (parm)
2240                         {
2241                                 case 0:
2242                                         printf("default ");
2243                                 case 2:
2244                                         printf("16-bit)\n");
2245                                         break;
2246                                 case 1:
2247                                         printf("32-bit)\n");
2248                                         break;
2249                                 case 3:
2250                                         printf("32-bit w/sync)\n");
2251                                         break;
2252                                 case 8:
2253                                         printf("Request-Queue-Bypass)\n");
2254                                         break;
2255                                 default:
2256                                         printf("\?\?\?)\n");
2257                                 /*esac*/
2258                         }
2259                 }
2260         }
2261         if ((verbose && !is_scsi_hd && !is_xt_hd) || get_unmask)
2262         {
2263                 no_scsi();
2264                 no_xt();
2265                 bb_ioctl_on_off(fd, HDIO_GET_UNMASKINTR,(unsigned long *)parm,
2266                                                 "HDIO_GET_UNMASKINTR"," unmaskirq    = %2ld");
2267         }
2268
2269
2270 #ifdef CONFIG_FEATURE_HDPARM_HDIO_GETSET_DMA
2271         if ((verbose && !is_scsi_hd) || get_dma) {
2272                 no_scsi();
2273                 if(ioctl(fd, HDIO_GET_DMA, &parm))
2274                         bb_perror_msg("HDIO_GET_DMA");
2275                 else
2276                 {
2277                         printf(" using_dma    = %2ld", parm);
2278                         if (parm == 8)
2279                                 printf(" (DMA-Assisted-PIO)\n");
2280                         else
2281                                 on_off(parm);
2282                 }
2283         }
2284 #endif
2285         if (get_dma_q)
2286         {
2287                 no_scsi();
2288                 bb_ioctl_on_off (fd, HDIO_GET_QDMA,(unsigned long *)parm,
2289                                                   "HDIO_GET_QDMA"," queue_depth  = %2ld");
2290         }
2291         if ((verbose && !is_scsi_hd && !is_xt_hd) || get_keep)
2292         {
2293                 no_scsi();
2294                 no_xt();
2295                 bb_ioctl_on_off (fd, HDIO_GET_KEEPSETTINGS,(unsigned long *)parm,
2296                                                         "HDIO_GET_KEEPSETTINGS"," keepsettings = %2ld");
2297         }
2298
2299         if (get_nowerr)
2300         {
2301                 no_scsi();
2302                 no_xt();
2303                 bb_ioctl_on_off  (fd, HDIO_GET_NOWERR,(unsigned long *)&parm,
2304                                                         " HDIO_GET_NOWERR"," nowerr       = %2ld");
2305         }
2306         if (verbose || get_readonly)
2307         {
2308                 bb_ioctl_on_off(fd, BLKROGET,(unsigned long *)parm,
2309                                                   " BLKROGET"," readonly     = %2ld");
2310         }
2311         if ((verbose && !is_scsi_hd) || get_readahead)
2312         {
2313                 bb_ioctl_on_off (fd, BLKRAGET, (unsigned long *) parm,
2314                                                         " BLKRAGET"," readahead    = %2ld");
2315         }
2316         if (verbose || get_geom)
2317         {
2318                 static const char msg[] = " geometry     = %u/%u/%u, sectors = %ld, start = %ld\n";
2319                 static struct hd_geometry g;
2320 #ifdef HDIO_GETGEO_BIG
2321                 static struct hd_big_geometry bg;
2322 #endif
2323
2324                 if (ioctl(fd, BLKGETSIZE, &parm))
2325                         bb_perror_msg("BLKGETSIZE");
2326 #ifdef HDIO_GETGEO_BIG
2327                 else if (!ioctl(fd, HDIO_GETGEO_BIG, &bg))
2328                         printf(msg, bg.cylinders, bg.heads, bg.sectors, parm, bg.start);
2329 #endif
2330                 else if (ioctl(fd, HDIO_GETGEO, &g))
2331                         bb_perror_msg("HDIO_GETGEO");
2332                 else
2333                         printf(msg, g.cylinders, g.heads, g.sectors, parm, g.start);
2334         }
2335 #ifdef HDIO_DRIVE_CMD
2336         if (get_powermode)
2337         {
2338 #ifndef WIN_CHECKPOWERMODE1
2339 #define WIN_CHECKPOWERMODE1 0xE5
2340 #endif
2341 #ifndef WIN_CHECKPOWERMODE2
2342 #define WIN_CHECKPOWERMODE2 0x98
2343 #endif
2344                 unsigned char args[4] = {WIN_CHECKPOWERMODE1,0,0,0};
2345                 const char *state;
2346                 no_scsi();
2347                 if (ioctl(fd, HDIO_DRIVE_CMD, &args)
2348                          && (args[0] = WIN_CHECKPOWERMODE2) /* try again with 0x98 */
2349                         && ioctl(fd, HDIO_DRIVE_CMD, &args))
2350                 {
2351                         if (errno != EIO || args[0] != 0 || args[1] != 0)
2352                                 state = "unknown";
2353                         else
2354                                 state = "sleeping";
2355                 }
2356                 else
2357                         state = (args[2] == 255) ? "active/idle" : "standby";
2358
2359                 printf(" drive state is:  %s\n", state);
2360         }
2361 #endif
2362 #ifdef CONFIG_FEATURE_HDPARM_HDIO_DRIVE_RESET
2363         if (perform_reset)
2364         {
2365                 no_scsi();
2366                 no_xt();
2367                 bb_ioctl(fd, HDIO_DRIVE_RESET, NULL, "HDIO_DRIVE_RESET");
2368         }
2369 #endif /* CONFIG_FEATURE_HDPARM_HDIO_DRIVE_RESET */
2370 #ifdef CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF
2371         if (perform_tristate)
2372         {
2373                 unsigned char args[4] = {0,tristate,0,0};
2374                 no_scsi();
2375                 no_xt();
2376                 bb_ioctl(fd, HDIO_TRISTATE_HWIF, &args, "HDIO_TRISTATE_HWIF");
2377         }
2378 #endif /* CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF */
2379 #ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY
2380         if (get_identity)
2381         {
2382                 static struct hd_driveid id;
2383
2384                 no_scsi();
2385                 no_xt();
2386
2387                 if (!ioctl(fd, HDIO_GET_IDENTITY, &id))
2388                 {
2389                         if (multcount != -1)
2390                         {
2391                                 id.multsect = multcount;
2392                                 id.multsect_valid |= 1;
2393                         }
2394                         else
2395                                 id.multsect_valid &= ~1;
2396                         dump_identity(&id);
2397                 }
2398                 else if (errno == -ENOMSG)
2399                         printf(" no identification info available\n");
2400                 else
2401                         bb_perror_msg("HDIO_GET_IDENTITY");
2402         }
2403
2404         if (get_IDentity)
2405         {
2406                 unsigned char args[4+512] = {WIN_IDENTIFY,0,0,1,};
2407                 unsigned i;
2408
2409                 no_scsi();
2410                 no_xt();
2411
2412                 if (ioctl(fd, HDIO_DRIVE_CMD, &args))
2413                 {
2414                         args[0] = WIN_PIDENTIFY;
2415                         if (ioctl(fd, HDIO_DRIVE_CMD, &args))
2416                         {
2417                                 bb_perror_msg("HDIO_DRIVE_CMD(identify)");
2418                                 goto identify_abort;
2419                         }
2420                 }
2421                 for(i=0; i<(sizeof args)/2; i+=2)
2422                     __le16_to_cpus((uint16_t *)(&args[i]));
2423
2424                 identify((void *)&args[4], NULL);
2425 identify_abort:
2426         /* VOID */;
2427         }
2428 #endif
2429 #ifdef CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF
2430         if (set_busstate)
2431         {
2432                 no_scsi();
2433                 if (get_busstate)
2434                 {
2435                         printf(" setting bus state to %d", busstate);
2436                         bus_state_value(busstate);
2437                 }
2438                 bb_ioctl(fd, HDIO_SET_BUSSTATE, (int *)busstate, "HDIO_SET_BUSSTATE");
2439         }
2440 #endif
2441 #ifdef CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF
2442         if (get_busstate)
2443         {
2444                 no_scsi();
2445                 if (ioctl(fd, HDIO_GET_BUSSTATE, &parm))
2446                         bb_perror_msg("HDIO_GET_BUSSTATE");
2447                 else
2448                 {
2449                         printf(" busstate     = %2ld", parm);
2450                         bus_state_value(parm);
2451                 }
2452         }
2453 #endif
2454         if (reread_partn)
2455                 bb_ioctl(fd, BLKRRPART, NULL, "BLKRRPART");
2456
2457
2458         if (do_ctimings)
2459                 do_time(0,fd);          /*time cache  */
2460         if (do_timings)
2461                 do_time(1,fd);          /*time device */
2462         if (do_flush)
2463                 flush_buffer_cache (fd);
2464         close (fd);
2465 }
2466
2467 static char * GET_NUMBER(char *p, unsigned long *flag, unsigned long *num)
2468 {
2469         *num = 0;
2470         while (isdigit(*p)) {
2471                 *flag = 1;
2472                 *num = (*num * 10) + (*p++ - '0');
2473         }
2474         return p;
2475 }
2476
2477 static char * GET_STRING(char *p, unsigned long *flag, int *num)
2478 {
2479         char *tmpstr;
2480         char name[32];
2481         tmpstr = name;
2482         tmpstr[0] = '\0';
2483         while (isalnum(*p) && (tmpstr - name) < 31) {
2484                 tmpstr[0] = *p++;
2485                 tmpstr[1] = '\0';
2486                 ++tmpstr;
2487         }
2488         *num = translate_xfermode(name);
2489         if (*num == -1)
2490                 *flag = 0;
2491         else
2492                 *flag = 1;
2493         return p;
2494 }
2495
2496 #ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY
2497 static int fromhex (unsigned char c)
2498 {
2499         if (c >= 'a' && c <= 'f')
2500                 return 10 + (c - 'a');
2501         if (c >= '0' && c <= '9')
2502                 return (c - '0');
2503         bb_error_msg_and_die("bad char: '%c' 0x%02x", c, c);
2504 }
2505
2506 static int identify_from_stdin (void)
2507 {
2508         unsigned short sbuf[800];
2509         unsigned char  buf[1600], *b = (unsigned char *)buf;
2510         int i, count = read(0, buf, 1280);
2511
2512         if (count != 1280)
2513                 bb_error_msg_and_die("read(1280 bytes) failed (rc=%d)", count);
2514         for (i = 0; count >= 4; ++i)
2515         {
2516                 sbuf[i] = (fromhex(b[0]) << 12) | (fromhex(b[1]) << 8) | (fromhex(b[2]) << 4) | fromhex(b[3]);
2517                 __le16_to_cpus((uint16_t *)(&sbuf[i]));
2518                 b += 5;
2519                 count -= 5;
2520         }
2521         identify(sbuf, NULL);
2522         return 0;
2523 }
2524 #endif
2525
2526 static void missing_arg(int arg, char c, char* add)
2527 {
2528         if (!arg)
2529                 bb_error_msg("-%c: missing value %s", c, (add!=NULL)? add :"");
2530 }
2531
2532 /* our main() routine: */
2533 int hdparm_main(int argc, char **argv)
2534 {
2535         char c, *p;
2536
2537         ++argv;
2538         if (!--argc)
2539                 bb_show_usage();
2540
2541         while (argc--)
2542         {
2543 #ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY
2544                 if (!strcmp("-Istdin", *argv))
2545                 {
2546                         return identify_from_stdin();
2547                 }
2548 #endif
2549                 p = *argv++;
2550                 if (*p == '-')
2551                 {
2552                         if (!*++p)
2553                                 bb_show_usage();
2554                         while ((c = *p++))
2555                         {
2556                                 ++flagcount;
2557                                 switch (c)
2558                                 {
2559                                         case 'V':
2560                                                 /*bb_error_msg_and_die("%s", VERSION);*/
2561                                                 /* We have to return 0 here and not 1 */
2562                                                 printf("%s %s\n",bb_applet_name, VERSION);
2563                                                 return EXIT_SUCCESS;
2564                                         case 'v':
2565                                                 verbose = 1;
2566                                                 break;
2567 #ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY
2568                                         case 'I':
2569                                                 get_IDentity = 1;
2570                                                 break;
2571                                         case 'i':
2572                                                 get_identity = 1;
2573                                                 break;
2574 #endif
2575                                         case 'g':
2576                                                 get_geom = 1;
2577                                                 break;
2578                                         case 'f':
2579                                                 do_flush = 1;
2580                                                 break;
2581                                         case 'q':
2582                                                 quiet = 1;
2583                                                 noisy = 0;
2584                                                 break;
2585                                         case 'u':
2586                                                 get_unmask = noisy;
2587                                                 noisy = 1;
2588                                                 if (!*p && argc && isdigit(**argv))
2589                                                         p = *argv++, --argc;
2590                                                 if((set_unmask = set_flag(p,'1'))==1)
2591                                                         unmask  = *p++ - '0';
2592                                                 break;
2593 #ifdef CONFIG_FEATURE_HDPARM_HDIO_GETSET_DMA
2594                                         case 'd':
2595                                                 get_dma = noisy;
2596                                                 noisy = 1;
2597                                                 if (!*p && argc && isdigit(**argv))
2598                                                         p = *argv++, --argc;
2599                                                 if((set_dma = set_flag(p,'9'))==1)
2600                                                         dma = *p++ - '0';
2601                                                 break;
2602 #endif /* CONFIG_FEATURE_HDPARM_HDIO_GETSET_DMA */
2603                                         case 'n':
2604                                                 get_nowerr = noisy;
2605                                                 noisy = 1;
2606                                                 if (!*p && argc && isdigit(**argv))
2607                                                         p = *argv++, --argc;
2608                                                 if((set_nowerr = set_flag(p,'1'))==1)
2609                                                         nowerr  = *p++ - '0';
2610                                                 break;
2611                                         case 'p':
2612                                                 noisy_piomode = noisy;
2613                                                 noisy = 1;
2614                                                 if (!*p && argc && isalnum(**argv))
2615                                                         p = *argv++, --argc;
2616                                                 p=GET_STRING(p,&set_piomode,&piomode);
2617                                                 break;
2618                                         case 'r':
2619                                                 get_readonly = noisy;
2620                                                 noisy = 1;
2621                                                 if (!*p && argc && isdigit(**argv))
2622                                                         p = *argv++, --argc;
2623                                                 if((set_readonly = set_flag(p,'1'))==1)
2624                                                         readonly  = *p++ - '0';
2625                                                 break;
2626                                         case 'm':
2627                                                 get_mult = noisy;
2628                                                 noisy = 1;
2629                                                 if (!*p && argc && isalnum(**argv))
2630                                                         p = *argv++, --argc;
2631                                                 p=GET_NUMBER(p,&set_mult,&mult);
2632                                                 break;
2633                                         case 'c':
2634                                                 get_io32bit = noisy;
2635                                                 noisy = 1;
2636                                                 if (!*p && argc && isalnum(**argv))
2637                                                         p = *argv++, --argc;
2638                                                 p=GET_NUMBER(p,&set_io32bit,&io32bit);
2639                                                 break;
2640 #ifdef HDIO_DRIVE_CMD
2641                                         case 'S':
2642                                                 get_standby = noisy;
2643                                                 noisy = 1;
2644                                                 if (!*p && argc && isalnum(**argv))
2645                                                         p = *argv++, --argc;
2646                                                 p=GET_NUMBER(p,&set_standby,&standby_requested);
2647                                                 missing_arg(set_standby, c, NULL);
2648                                                 break;
2649
2650                                         case 'D':
2651                                                 get_defects = noisy;
2652                                                 noisy = 1;
2653                                                 if (!*p && argc && isalnum(**argv))
2654                                                         p = *argv++, --argc;
2655                                                 p=GET_NUMBER(p,&set_defects,&defects);
2656                                                 missing_arg(set_defects, c, NULL);
2657                                                 break;
2658                                         case 'P':
2659                                                 get_prefetch = noisy;
2660                                                 noisy = 1;
2661                                                 if (!*p && argc && isalnum(**argv))
2662                                                         p = *argv++, --argc;
2663                                                 p=GET_NUMBER(p,&set_prefetch,&prefetch);
2664                                                 missing_arg(set_prefetch, c, NULL);
2665                                                 break;
2666
2667                                         case 'X':
2668                                                 get_xfermode = noisy;
2669                                                 noisy = 1;
2670                                                 if (!*p && argc && isalnum(**argv))
2671                                                         p = *argv++, --argc;
2672                                                 p=GET_STRING(p,&set_xfermode,&xfermode_requested);
2673                                                 missing_arg(set_xfermode, c, NULL);
2674                                                 break;
2675
2676                                         case 'K':
2677                                                 get_dkeep = noisy;
2678                                                 noisy = 1;
2679                                                 if (!*p && argc && isdigit(**argv))
2680                                                         p = *argv++, --argc;
2681                                                 if((set_dkeep = set_flag(p,'1'))==1)
2682                                                         dkeep  = *p++ - '0';
2683                                                 else
2684                                                         goto missing_arg_error;
2685                                                 break;
2686
2687                                         case 'A':
2688                                                 get_lookahead = noisy;
2689                                                 noisy = 1;
2690                                                 if (!*p && argc && isdigit(**argv))
2691                                                         p = *argv++, --argc;
2692                                                 if((set_lookahead = set_flag(p,'1'))==1)
2693                                                         lookahead  = *p++ - '0';
2694                                                 else
2695                                                         goto missing_arg_error;
2696                                                 break;
2697
2698                                         case 'L':
2699                                                 get_doorlock = noisy;
2700                                                 noisy = 1;
2701                                                 if (!*p && argc && isdigit(**argv))
2702                                                         p = *argv++, --argc;
2703                                                 if((set_doorlock = set_flag(p,'1'))==1)
2704                                                         doorlock  = *p++ - '0';
2705                                                 else
2706                                                         goto missing_arg_error;
2707                                                 break;
2708
2709                                         case 'W':
2710                                                 get_wcache = noisy;
2711                                                 noisy = 1;
2712                                                 if (!*p && argc && isdigit(**argv))
2713                                                         p = *argv++, --argc;
2714                                                 if((set_wcache = set_flag(p,'1'))==1)
2715                                                         wcache  = *p++ - '0';
2716                                                 else
2717 missing_arg_error:
2718                                                         missing_arg(1, c, "(0/1)");
2719                                                 break;
2720
2721                                         case 'C':
2722                                                 get_powermode = noisy;
2723                                                 noisy = 1;
2724                                                 break;
2725
2726                                         case 'y':
2727                                                 get_standbynow = noisy;
2728                                                 noisy = 1;
2729                                                 set_standbynow = 1;
2730                                                 break;
2731
2732                                         case 'Y':
2733                                                 get_sleepnow = noisy;
2734                                                 noisy = 1;
2735                                                 set_sleepnow = 1;
2736                                                 break;
2737
2738                                         case 'z':
2739                                                 reread_partn = 1;
2740                                                 break;
2741
2742                                         case 'Z':
2743                                                 get_seagate = noisy;
2744                                                 noisy = 1;
2745                                                 set_seagate = 1;
2746                                                 break;
2747 #endif /* HDIO_DRIVE_CMD */
2748                                         case 'k':
2749                                                 get_keep = noisy;
2750                                                 noisy = 1;
2751                                                 if (!*p && argc && isdigit(**argv))
2752                                                         p = *argv++, --argc;
2753                                                 if((set_keep = set_flag(p,'1'))==1)
2754                                                         keep  = *p++ - '0';
2755                                                 break;
2756 #ifdef CONFIG_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF
2757                                         case 'U':
2758                                                 if (!*p && argc && isdigit(**argv))
2759                                                         p = *argv++, --argc;
2760                                                 if(! p)
2761                                                         goto expected_hwif_error; /* "expected hwif_nr" */
2762
2763                                                 sscanf(p++, "%i", &hwif);
2764
2765                                                 unregister_hwif = 1;
2766                                                 break;
2767 #endif /* CONFIG_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF */
2768 #ifdef CONFIG_FEATURE_HDPARM_HDIO_SCAN_HWIF
2769                                         case 'R':
2770                                                 if (!*p && argc && isdigit(**argv))
2771                                                         p = *argv++, --argc;
2772                                                 if(! p)
2773                                                         goto expected_hwif_error; /* "expected hwif_data" */
2774
2775                                                 sscanf(p++, "%i", &hwif_data);
2776
2777                                                 if (argc && isdigit(**argv))
2778                                                         p = *argv++, --argc;
2779                                                 else
2780                                                         goto expected_hwif_error; /* "expected hwif_ctrl" */
2781
2782                                                 sscanf(p, "%i", &hwif_ctrl);
2783
2784                                                 if (argc && isdigit(**argv))
2785                                                         p = *argv++, --argc;
2786                                                 else
2787 expected_hwif_error:
2788                                                         bb_error_msg_and_die("expected hwif value"); /* "expected hwif_irq" */
2789
2790                                                 sscanf(p, "%i", &hwif_irq);
2791
2792                                                 *p = '\0';
2793
2794                                                 scan_hwif = 1;
2795                                                 break;
2796 #endif /* CONFIG_FEATURE_HDPARM_HDIO_SCAN_HWIF */
2797                                         case 'Q':
2798 #ifdef HDIO_GET_QDMA
2799                                                 get_dma_q = noisy;
2800                                                 noisy = 1;
2801 #ifdef HDIO_SET_QDMA
2802                                                 if (!*p && argc && isalnum(**argv))
2803                                                         p = *argv++, --argc;
2804                                                 p=GET_NUMBER(p,&set_dma_q,&dma_q);
2805 #ifdef HDIO_GET_QDMA
2806                                                 dma_q = -dma_q;
2807 #endif
2808 #endif
2809 #endif
2810                                                 break;
2811
2812 #ifdef CONFIG_FEATURE_HDPARM_HDIO_DRIVE_RESET
2813                                         case 'w':
2814                                                 perform_reset = 1;
2815                                                 break;
2816 #endif /* CONFIG_FEATURE_HDPARM_HDIO_DRIVE_RESET */
2817 #ifdef CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF
2818                                         case 'x':
2819                                                 if (!*p && argc && isdigit(**argv))
2820                                                         p = *argv++, --argc;
2821                                                 if((perform_tristate = set_flag(p,'1'))==1)
2822                                                         tristate  = *p++ - '0';
2823                                                 else
2824                                                         missing_arg(1, c, "(0/1)");
2825                                                 break;
2826
2827 #endif /* CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF */
2828                                         case 'a':
2829                                                 get_readahead = noisy;
2830                                                 noisy = 1;
2831                                                 if (!*p && argc && isalnum(**argv))
2832                                                         p = *argv++, --argc;
2833                                                 p=GET_NUMBER(p,&set_readahead,&Xreadahead);
2834                                                 break;
2835                                         case 'B':
2836                                                 get_apmmode = noisy;
2837                                                 noisy = 1;
2838                                                 if (!*p && argc && isalnum(**argv))
2839                                                         p = *argv++, --argc;
2840                                                 p=GET_NUMBER(p,&set_apmmode,&apmmode);
2841                                                 missing_arg(set_apmmode, c, "(1-255)");
2842                                                 break;
2843                                         case 't':
2844                                                 do_timings = 1;
2845                                                 do_flush = 1;
2846                                                 break;
2847                                         case 'T':
2848                                                 do_ctimings = 1;
2849                                                 do_flush = 1;
2850                                                 break;
2851 #ifdef CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF
2852                                         case 'b':
2853                                                 get_busstate = noisy;
2854                                                 noisy = 1;
2855                                                 if (!*p && argc && isdigit(**argv))
2856                                                         p = *argv++, --argc;
2857                                                 if((set_busstate = set_flag(p,'2'))==1)
2858                                                         busstate  = *p++ - '0';
2859                                                 break;
2860 #endif
2861                                         case 'h':
2862                                         default:
2863                                                 bb_show_usage();
2864                                 }
2865                         }
2866                         if (!argc)
2867                                 bb_show_usage();
2868                 } else {
2869                         process_dev (p);
2870                 }
2871         }
2872         return 0 ;
2873 }