diff options
Diffstat (limited to 'release/src/router/busybox/miscutils/hdparm.c')
| -rw-r--r-- | release/src/router/busybox/miscutils/hdparm.c | 3432 |
1 files changed, 1415 insertions, 2017 deletions
diff --git a/release/src/router/busybox/miscutils/hdparm.c b/release/src/router/busybox/miscutils/hdparm.c index 1e34f4f4..de5d68a0 100644 --- a/release/src/router/busybox/miscutils/hdparm.c +++ b/release/src/router/busybox/miscutils/hdparm.c @@ -2,53 +2,18 @@ /* * hdparm implementation for busybox * + * Copyright (C) [2003] by [Matteo Croce] <3297627799@wind.it> + * Hacked by Tito <farmatito@tiscali.it> for size optimization. * - * Copyright (C) [2003] by [Matteo Croce] <pinnolo@tin.it> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA - * 02111-1307 USA - * + * Licensed under the GPL v2 or later, see the file LICENSE in this tarball. * * This program is based on the source code of hdparm: see below... * hdparm.c - Command line interface to get/set hard disk parameters * - by Mark Lord (C) 1994-2002 -- freely distributable */ - -#include <unistd.h> -#include <string.h> -#include <stdlib.h> -#include <fcntl.h> -#include <errno.h> -#include <ctype.h> -#include <endian.h> -#include <sys/ioctl.h> -#include <sys/shm.h> -#include <sys/sysmacros.h> -#include <sys/time.h> -#include <sys/times.h> -#include <sys/mount.h> -#include "busybox.h" -#include <linux/types.h> -#include <linux/hdreg.h> -#include <linux/major.h> -#include <asm/byteorder.h> - -#if __BYTE_ORDER == __BIG_ENDIAN -#define __USE_XOPEN -#endif +#include "libbb.h" +#include <linux/hdreg.h> /* device types */ /* ------------ */ @@ -72,9 +37,9 @@ #define RW_LONG 22 /* extra bytes in R/W LONG cmd ( < ATA-4)*/ #define START_FW_REV 23 /* ASCII firmware revision */ #define LENGTH_FW_REV 4 /* 4 words (8 bytes or characters) */ -#define START_MODEL 27 /* ASCII model number */ -#define LENGTH_MODEL 20 /* 20 words (40 bytes or characters) */ -#define SECTOR_XFER_MAX 47 /* r/w multiple: max sectors xfered */ +#define START_MODEL 27 /* ASCII model number */ +#define LENGTH_MODEL 20 /* 20 words (40 bytes or characters) */ +#define SECTOR_XFER_MAX 47 /* r/w multiple: max sectors xfered */ #define DWORD_IO 48 /* can do double-word IO (ATA-1 only) */ #define CAPAB_0 49 /* capabilities */ #define CAPAB_1 50 @@ -83,7 +48,7 @@ #define WHATS_VALID 53 /* what fields are valid */ #define LCYLS_CUR 54 /* current logical cylinders */ #define LHEADS_CUR 55 /* current logical heads */ -#define LSECTS_CUR 56 /* current logical sectors/track */ +#define LSECTS_CUR 56 /* current logical sectors/track */ #define CAPACITY_LSB 57 /* current capacity in sectors */ #define CAPACITY_MSB 58 #define SECTOR_XFER_CUR 59 /* r/w multiple: current sectors xfered */ @@ -94,7 +59,7 @@ #define ADV_PIO_MODES 64 /* advanced PIO modes supported */ /* multiword DMA xfer cycle time: */ #define DMA_TIME_MIN 65 /* - minimum */ -#define DMA_TIME_NORM 66 /* - manufacturer's recommended */ +#define DMA_TIME_NORM 66 /* - manufacturer's recommended */ /* minimum PIO xfer cycle time: */ #define PIO_NO_FLOW 67 /* - without flow control */ #define PIO_FLOW 68 /* - with IORDY flow control */ @@ -116,15 +81,15 @@ #define ERASE_TIME 89 /* - ordinary */ #define ENH_ERASE_TIME 90 /* - enhanced */ #define ADV_PWR 91 /* current advanced power management level - in low byte, 0x40 in high byte. */ -#define PSWD_CODE 92 /* master password revision code */ + in low byte, 0x40 in high byte. */ +#define PSWD_CODE 92 /* master password revision code */ #define HWRST_RSLT 93 /* hardware reset result */ -#define ACOUSTIC 94 /* acoustic mgmt values ( >= ATA-6) */ +#define ACOUSTIC 94 /* acoustic mgmt values ( >= ATA-6) */ #define LBA_LSB 100 /* LBA: maximum. Currently only 48 */ #define LBA_MID 101 /* bits are used, but addr 103 */ #define LBA_48_MSB 102 /* has been reserved for LBA in */ #define LBA_64_MSB 103 /* the future. */ -#define RM_STAT 127 /* removable media status notification feature set support */ +#define RM_STAT 127 /* removable media status notification feature set support */ #define SECU_STATUS 128 /* security status */ #define CFA_PWR_MODE 160 /* CFA power mode 1 */ #define START_MEDIA 176 /* media serial number */ @@ -144,7 +109,7 @@ #define NOVAL_1 0xffff /* word 0: gen_config */ -#define NOT_ATA 0x8000 +#define NOT_ATA 0x8000 #define NOT_ATAPI 0x4000 /* (check only if bit 15 == 1) */ #define MEDIA_REMOVABLE 0x0080 #define DRIVE_NOT_REMOVABLE 0x0040 /* bit obsoleted in ATA 6 */ @@ -162,71 +127,16 @@ #define CDROM 0x0005 -#ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY -static const char *pkt_str[] = { - "Direct-access device", /* word 0, bits 12-8 = 00 */ - "Sequential-access device", /* word 0, bits 12-8 = 01 */ - "Printer", /* word 0, bits 12-8 = 02 */ - "Processor", /* word 0, bits 12-8 = 03 */ - "Write-once device", /* word 0, bits 12-8 = 04 */ - "CD-ROM", /* word 0, bits 12-8 = 05 */ - "Scanner", /* word 0, bits 12-8 = 06 */ - "Optical memory", /* word 0, bits 12-8 = 07 */ - "Medium changer", /* word 0, bits 12-8 = 08 */ - "Communications device", /* word 0, bits 12-8 = 09 */ - "ACS-IT8 device", /* word 0, bits 12-8 = 0a */ - "ACS-IT8 device", /* word 0, bits 12-8 = 0b */ - "Array controller", /* word 0, bits 12-8 = 0c */ - "Enclosure services", /* word 0, bits 12-8 = 0d */ - "Reduced block command device", /* word 0, bits 12-8 = 0e */ - "Optical card reader/writer", /* word 0, bits 12-8 = 0f */ - "", /* word 0, bits 12-8 = 10 */ - "", /* word 0, bits 12-8 = 11 */ - "", /* word 0, bits 12-8 = 12 */ - "", /* word 0, bits 12-8 = 13 */ - "", /* word 0, bits 12-8 = 14 */ - "", /* word 0, bits 12-8 = 15 */ - "", /* word 0, bits 12-8 = 16 */ - "", /* word 0, bits 12-8 = 17 */ - "", /* word 0, bits 12-8 = 18 */ - "", /* word 0, bits 12-8 = 19 */ - "", /* word 0, bits 12-8 = 1a */ - "", /* word 0, bits 12-8 = 1b */ - "", /* word 0, bits 12-8 = 1c */ - "", /* word 0, bits 12-8 = 1d */ - "", /* word 0, bits 12-8 = 1e */ - "Unknown", /* word 0, bits 12-8 = 1f */ -}; -static const char *ata1_cfg_str[] = { /* word 0 in ATA-1 mode */ - "reserved", /* bit 0 */ - "hard sectored", /* bit 1 */ - "soft sectored", /* bit 2 */ - "not MFM encoded ", /* bit 3 */ - "head switch time > 15us", /* bit 4 */ - "spindle motor control option", /* bit 5 */ - "fixed drive", /* bit 6 */ - "removable drive", /* bit 7 */ - "disk xfer rate <= 5Mbs", /* bit 8 */ - "disk xfer rate > 5Mbs, <= 10Mbs", /* bit 9 */ - "disk xfer rate > 5Mbs", /* bit 10 */ - "rotational speed tol.", /* bit 11 */ - "data strobe offset option", /* bit 12 */ - "track offset option", /* bit 13 */ - "format speed tolerance gap reqd", /* bit 14 */ - "ATAPI" /* bit 14 */ -}; -#endif - /* word 1: number of logical cylinders */ #define LCYLS_MAX 0x3fff /* maximum allowable value */ -/* word 2: specific configureation +/* word 2: specific configuration * (a) require SET FEATURES to spin-up * (b) require spin-up to fully reply to IDENTIFY DEVICE */ #define STBY_NID_VAL 0x37c8 /* (a) and (b) */ #define STBY_ID_VAL 0x738c /* (a) and not (b) */ -#define PWRD_NID_VAL 0x8c73 /* not (a) and (b) */ +#define PWRD_NID_VAL 0x8c73 /* not (a) and (b) */ #define PWRD_ID_VAL 0xc837 /* not (a) and not (b) */ /* words 47 & 59: sector_xfer_max & sector_xfer_cur */ @@ -234,8 +144,7 @@ static const char *ata1_cfg_str[] = { /* word 0 in ATA-1 mode */ #define MULTIPLE_SETTING_VALID 0x0100 /* 1=multiple sector setting is valid */ /* word 49: capabilities 0 */ -#define STD_STBY 0x2000 /* 1=standard values supported (ATA); - 0=vendor specific values */ +#define STD_STBY 0x2000 /* 1=standard values supported (ATA); 0=vendor specific values */ #define IORDY_SUP 0x0800 /* 1=support; 0=may be supported */ #define IORDY_OFF 0x0400 /* 1=may be disabled */ #define LBA_SUP 0x0200 /* 1=Logical Block Address support */ @@ -252,7 +161,7 @@ static const char *ata1_cfg_str[] = { /* word 0 in ATA-1 mode */ #define MODE 0xff00 /* the mode is in the MSBs */ /* word 53: whats_valid */ -#define OK_W88 0x0004 /* the ultra_dma info is valid */ +#define OK_W88 0x0004 /* the ultra_dma info is valid */ #define OK_W64_70 0x0002 /* see above for word descriptions */ #define OK_W54_58 0x0001 /* current cyl, head, sector, cap. info valid */ @@ -272,818 +181,974 @@ static const char *ata1_cfg_str[] = { /* word 0 in ATA-1 mode */ /* NOVAL_0 or NOVAL_1 means device does not report version */ /* word 81: minor version number */ -#define MINOR_MAX 0x1C -#ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY -static const char *minor_str[] = { /* word 81 value: */ - "device does not report version", /* 0x0000 */ - "ATA-1 X3T9.2 781D prior to revision 4", /* 0x0001 */ - "ATA-1 published, ANSI X3.221-1994", /* 0x0002 */ - "ATA-1 X3T9.2 781D revision 4", /* 0x0003 */ - "ATA-2 published, ANSI X3.279-1996", /* 0x0004 */ - "ATA-2 X3T10 948D prior to revision 2k", /* 0x0005 */ - "ATA-3 X3T10 2008D revision 1", /* 0x0006 */ - "ATA-2 X3T10 948D revision 2k", /* 0x0007 */ - "ATA-3 X3T10 2008D revision 0", /* 0x0008 */ - "ATA-2 X3T10 948D revision 3", /* 0x0009 */ - "ATA-3 published, ANSI X3.298-199x", /* 0x000a */ - "ATA-3 X3T10 2008D revision 6", /* 0x000b */ - "ATA-3 X3T13 2008D revision 7 and 7a", /* 0x000c */ - "ATA/ATAPI-4 X3T13 1153D revision 6", /* 0x000d */ - "ATA/ATAPI-4 T13 1153D revision 13", /* 0x000e */ - "ATA/ATAPI-4 X3T13 1153D revision 7", /* 0x000f */ - "ATA/ATAPI-4 T13 1153D revision 18", /* 0x0010 */ - "ATA/ATAPI-4 T13 1153D revision 15", /* 0x0011 */ - "ATA/ATAPI-4 published, ANSI NCITS 317-1998", /* 0x0012 */ - "ATA/ATAPI-5 T13 1321D revision 3", - "ATA/ATAPI-4 T13 1153D revision 14", /* 0x0014 */ - "ATA/ATAPI-5 T13 1321D revision 1", /* 0x0015 */ - "ATA/ATAPI-5 published, ANSI NCITS 340-2000", /* 0x0016 */ - "ATA/ATAPI-4 T13 1153D revision 17", /* 0x0017 */ - "ATA/ATAPI-6 T13 1410D revision 0", /* 0x0018 */ - "ATA/ATAPI-6 T13 1410D revision 3a", /* 0x0019 */ - "Reserved", /* 0x001a */ - "ATA/ATAPI-6 T13 1410D revision 2", /* 0x001b */ - "ATA/ATAPI-6 T13 1410D revision 1", /* 0x001c */ - "reserved" /* 0x001d */ - "reserved" /* 0x001e */ - "reserved" /* 0x001f-0xfffe*/ -}; -#endif -static const char actual_ver[] = { - /* word 81 value: */ - 0, /* 0x0000 WARNING: */ - 1, /* 0x0001 WARNING: */ - 1, /* 0x0002 WARNING: */ - 1, /* 0x0003 WARNING: */ - 2, /* 0x0004 WARNING: This array */ - 2, /* 0x0005 WARNING: corresponds */ - 3, /* 0x0006 WARNING: *exactly* */ - 2, /* 0x0007 WARNING: to the ATA/ */ - 3, /* 0x0008 WARNING: ATAPI version */ - 2, /* 0x0009 WARNING: listed in */ - 3, /* 0x000a WARNING: the */ - 3, /* 0x000b WARNING: minor_str */ - 3, /* 0x000c WARNING: array */ - 4, /* 0x000d WARNING: above. */ - 4, /* 0x000e WARNING: */ - 4, /* 0x000f WARNING: if you change */ - 4, /* 0x0010 WARNING: that one, */ - 4, /* 0x0011 WARNING: change this one */ - 4, /* 0x0012 WARNING: too!!! */ - 5, /* 0x0013 WARNING: */ - 4, /* 0x0014 WARNING: */ - 5, /* 0x0015 WARNING: */ - 5, /* 0x0016 WARNING: */ - 4, /* 0x0017 WARNING: */ - 6, /* 0x0018 WARNING: */ - 6, /* 0x0019 WARNING: */ - 0, /* 0x001a WARNING: */ - 6, /* 0x001b WARNING: */ - 6, /* 0x001c WARNING: */ - 0 /* 0x001d-0xfffe */ -}; - +#define MINOR_MAX 0x22 /* words 82-84: cmds/feats supported */ #define CMDS_W82 0x77ff /* word 82: defined command locations*/ #define CMDS_W83 0x3fff /* word 83: defined command locations*/ #define CMDS_W84 0x002f /* word 83: defined command locations*/ -#define SUPPORT_48_BIT 0x0400 +#define SUPPORT_48_BIT 0x0400 #define NUM_CMD_FEAT_STR 48 -#ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY -static const char *cmd_feat_str[] = { - "", /* word 82 bit 15: obsolete */ - "NOP cmd", /* word 82 bit 14 */ - "READ BUFFER cmd", /* word 82 bit 13 */ - "WRITE BUFFER cmd", /* word 82 bit 12 */ - "", /* word 82 bit 11: obsolete */ - "Host Protected Area feature set", /* word 82 bit 10 */ - "DEVICE RESET cmd", /* word 82 bit 9 */ - "SERVICE interrupt", /* word 82 bit 8 */ - "Release interrupt", /* word 82 bit 7 */ - "Look-ahead", /* word 82 bit 6 */ - "Write cache", /* word 82 bit 5 */ - "PACKET command feature set", /* word 82 bit 4 */ - "Power Management feature set", /* word 82 bit 3 */ - "Removable Media feature set", /* word 82 bit 2 */ - "Security Mode feature set", /* word 82 bit 1 */ - "SMART feature set", /* word 82 bit 0 */ - /* --------------*/ - "", /* word 83 bit 15: !valid bit */ - "", /* word 83 bit 14: valid bit */ - "FLUSH CACHE EXT command", /* word 83 bit 13 */ - "Mandatory FLUSH CACHE command ", /* word 83 bit 12 */ - "Device Configuration Overlay feature set ", - "48-bit Address feature set ", /* word 83 bit 10 */ - "", - "SET MAX security extension", /* word 83 bit 8 */ - "Address Offset Reserved Area Boot", /* word 83 bit 7 */ - "SET FEATURES subcommand required to spinup after power up", - "Power-Up In Standby feature set", /* word 83 bit 5 */ - "Removable Media Status Notification feature set", - "Advanced Power Management feature set",/* word 83 bit 3 */ - "CFA feature set", /* word 83 bit 2 */ - "READ/WRITE DMA QUEUED", /* word 83 bit 1 */ - "DOWNLOAD MICROCODE cmd", /* word 83 bit 0 */ - /* --------------*/ - "", /* word 84 bit 15: !valid bit */ - "", /* word 84 bit 14: valid bit */ - "", /* word 84 bit 13: reserved */ - "", /* word 84 bit 12: reserved */ - "", /* word 84 bit 11: reserved */ - "", /* word 84 bit 10: reserved */ - "", /* word 84 bit 9: reserved */ - "", /* word 84 bit 8: reserved */ - "", /* word 84 bit 7: reserved */ - "", /* word 84 bit 6: reserved */ - "General Purpose Logging feature set", /* word 84 bit 5 */ - "", /* word 84 bit 4: reserved */ - "Media Card Pass Through Command feature set ", - "Media serial number ", /* word 84 bit 2 */ - "SMART self-test ", /* word 84 bit 1 */ - "SMART error logging " /* word 84 bit 0 */ -}; -#endif - - /* words 85-87: cmds/feats enabled */ /* use cmd_feat_str[] to display what commands and features have - * been enabled with words 85-87 + * been enabled with words 85-87 */ /* words 89, 90, SECU ERASE TIME */ -#define ERASE_BITS 0x00ff +#define ERASE_BITS 0x00ff /* word 92: master password revision */ /* NOVAL_0 or NOVAL_1 means no support for master password revision */ /* word 93: hw reset result */ -#define CBLID 0x2000 /* CBLID status */ -#define RST0 0x0001 /* 1=reset to device #0 */ -#define DEV_DET 0x0006 /* how device num determined */ -#define JUMPER_VAL 0x0002 /* device num determined by jumper */ -#define CSEL_VAL 0x0004 /* device num determined by CSEL_VAL */ +#define CBLID 0x2000 /* CBLID status */ +#define RST0 0x0001 /* 1=reset to device #0 */ +#define DEV_DET 0x0006 /* how device num determined */ +#define JUMPER_VAL 0x0002 /* device num determined by jumper */ +#define CSEL_VAL 0x0004 /* device num determined by CSEL_VAL */ /* word 127: removable media status notification feature set support */ -#define RM_STAT_BITS 0x0003 -#define RM_STAT_SUP 0x0001 - +#define RM_STAT_BITS 0x0003 +#define RM_STAT_SUP 0x0001 + /* word 128: security */ -#define SECU_ENABLED 0x0002 -#define SECU_LEVEL 0x0010 -#define NUM_SECU_STR 6 -#ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY -static const char *secu_str[] = { - "supported", /* word 128, bit 0 */ - "enabled", /* word 128, bit 1 */ - "locked", /* word 128, bit 2 */ - "frozen", /* word 128, bit 3 */ - "expired: security count", /* word 128, bit 4 */ - "supported: enhanced erase" /* word 128, bit 5 */ -}; -#endif +#define SECU_ENABLED 0x0002 +#define SECU_LEVEL 0x0010 +#define NUM_SECU_STR 6 /* word 160: CFA power mode */ -#define VALID_W160 0x8000 /* 1=word valid */ -#define PWR_MODE_REQ 0x2000 /* 1=CFA power mode req'd by some cmds*/ -#define PWR_MODE_OFF 0x1000 /* 1=CFA power moded disabled */ -#define MAX_AMPS 0x0fff /* value = max current in ma */ +#define VALID_W160 0x8000 /* 1=word valid */ +#define PWR_MODE_REQ 0x2000 /* 1=CFA power mode req'd by some cmds*/ +#define PWR_MODE_OFF 0x1000 /* 1=CFA power moded disabled */ +#define MAX_AMPS 0x0fff /* value = max current in ma */ /* word 255: integrity */ -#define SIG 0x00ff /* signature location */ -#define SIG_VAL 0x00A5 /* signature value */ +#define SIG 0x00ff /* signature location */ +#define SIG_VAL 0x00a5 /* signature value */ -#ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY -static uint8_t mode_loop(uint16_t mode_sup, uint16_t mode_sel, int cc, uint8_t *have_mode) { - uint16_t ii; - uint8_t err_dma = 0; - for(ii = 0; ii <= MODE_MAX; ii++) { - if(mode_sel & 0x0001) { - printf("*%cdma%u ",cc,ii); - if(*have_mode) err_dma = 1; - *have_mode = 1; - } else if(mode_sup & 0x0001) { - printf("%cdma%u ",cc,ii); - } - mode_sup >>=1; mode_sel >>=1; +#define TIMING_BUF_MB 1 +#define TIMING_BUF_BYTES (TIMING_BUF_MB * 1024 * 1024) + +#undef DO_FLUSHCACHE /* under construction: force cache flush on -W0 */ + + +enum { fd = 3 }; + + +struct globals { + smallint get_identity, get_geom; + smallint do_flush; + smallint do_ctimings, do_timings; + smallint reread_partn; + smallint set_piomode, noisy_piomode; + smallint set_readahead, get_readahead; + smallint set_readonly, get_readonly; + smallint set_unmask, get_unmask; + smallint set_mult, get_mult; +#ifdef HDIO_GET_QDMA + smallint get_dma_q; +#ifdef HDIO_SET_QDMA + smallint set_dma_q; +#endif +#endif + smallint set_nowerr, get_nowerr; + smallint set_keep, get_keep; + smallint set_io32bit, get_io32bit; + int piomode; + unsigned long Xreadahead; + unsigned long readonly; + unsigned long unmask; + unsigned long mult; +#ifdef HDIO_SET_QDMA + unsigned long dma_q; +#endif + unsigned long nowerr; + unsigned long keep; + unsigned long io32bit; +#if ENABLE_FEATURE_HDPARM_HDIO_GETSET_DMA + unsigned long dma; + smallint set_dma, get_dma; +#endif +#ifdef HDIO_DRIVE_CMD + smallint set_xfermode, get_xfermode; + smallint set_dkeep, get_dkeep; + smallint set_standby, get_standby; + smallint set_lookahead, get_lookahead; + smallint set_prefetch, get_prefetch; + smallint set_defects, get_defects; + smallint set_wcache, get_wcache; + smallint set_doorlock, get_doorlock; + smallint set_seagate, get_seagate; + smallint set_standbynow, get_standbynow; + smallint set_sleepnow, get_sleepnow; + smallint get_powermode; + smallint set_apmmode, get_apmmode; + int xfermode_requested; + unsigned long dkeep; + unsigned long standby_requested; /* 0..255 */ + unsigned long lookahead; + unsigned long prefetch; + unsigned long defects; + unsigned long wcache; + unsigned long doorlock; + unsigned long apmmode; +#endif + USE_FEATURE_HDPARM_GET_IDENTITY( smallint get_IDentity;) + USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF( smallint set_busstate, get_busstate;) + USE_FEATURE_HDPARM_HDIO_DRIVE_RESET( smallint perform_reset;) + USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF( smallint perform_tristate;) + USE_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF(smallint unregister_hwif;) + USE_FEATURE_HDPARM_HDIO_SCAN_HWIF( smallint scan_hwif;) + USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF( unsigned long busstate;) + USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF( unsigned long tristate;) + USE_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF(unsigned long hwif;) +#if ENABLE_FEATURE_HDPARM_HDIO_SCAN_HWIF + unsigned long hwif_data; + unsigned long hwif_ctrl; + unsigned long hwif_irq; +#endif +#ifdef DO_FLUSHCACHE + unsigned char flushcache[4] = { WIN_FLUSHCACHE, 0, 0, 0 }; +#endif +}; +#define G (*(struct globals*)&bb_common_bufsiz1) +struct BUG_G_too_big { + char BUG_G_too_big[sizeof(G) <= COMMON_BUFSIZE ? 1 : -1]; +}; +#define get_identity (G.get_identity ) +#define get_geom (G.get_geom ) +#define do_flush (G.do_flush ) +#define do_ctimings (G.do_ctimings ) +#define do_timings (G.do_timings ) +#define reread_partn (G.reread_partn ) +#define set_piomode (G.set_piomode ) +#define noisy_piomode (G.noisy_piomode ) +#define set_readahead (G.set_readahead ) +#define get_readahead (G.get_readahead ) +#define set_readonly (G.set_readonly ) +#define get_readonly (G.get_readonly ) +#define set_unmask (G.set_unmask ) +#define get_unmask (G.get_unmask ) +#define set_mult (G.set_mult ) +#define get_mult (G.get_mult ) +#define set_dma_q (G.set_dma_q ) +#define get_dma_q (G.get_dma_q ) +#define set_nowerr (G.set_nowerr ) +#define get_nowerr (G.get_nowerr ) +#define set_keep (G.set_keep ) +#define get_keep (G.get_keep ) +#define set_io32bit (G.set_io32bit ) +#define get_io32bit (G.get_io32bit ) +#define piomode (G.piomode ) +#define Xreadahead (G.Xreadahead ) +#define readonly (G.readonly ) +#define unmask (G.unmask ) +#define mult (G.mult ) +#define dma_q (G.dma_q ) +#define nowerr (G.nowerr ) +#define keep (G.keep ) +#define io32bit (G.io32bit ) +#define dma (G.dma ) +#define set_dma (G.set_dma ) +#define get_dma (G.get_dma ) +#define set_xfermode (G.set_xfermode ) +#define get_xfermode (G.get_xfermode ) +#define set_dkeep (G.set_dkeep ) +#define get_dkeep (G.get_dkeep ) +#define set_standby (G.set_standby ) +#define get_standby (G.get_standby ) +#define set_lookahead (G.set_lookahead ) +#define get_lookahead (G.get_lookahead ) +#define set_prefetch (G.set_prefetch ) +#define get_prefetch (G.get_prefetch ) +#define set_defects (G.set_defects ) +#define get_defects (G.get_defects ) +#define set_wcache (G.set_wcache ) +#define get_wcache (G.get_wcache ) +#define set_doorlock (G.set_doorlock ) +#define get_doorlock (G.get_doorlock ) +#define set_seagate (G.set_seagate ) +#define get_seagate (G.get_seagate ) +#define set_standbynow (G.set_standbynow ) +#define get_standbynow (G.get_standbynow ) +#define set_sleepnow (G.set_sleepnow ) +#define get_sleepnow (G.get_sleepnow ) +#define get_powermode (G.get_powermode ) +#define set_apmmode (G.set_apmmode ) +#define get_apmmode (G.get_apmmode ) +#define xfermode_requested (G.xfermode_requested ) +#define dkeep (G.dkeep ) +#define standby_requested (G.standby_requested ) +#define lookahead (G.lookahead ) +#define prefetch (G.prefetch ) +#define defects (G.defects ) +#define wcache (G.wcache ) +#define doorlock (G.doorlock ) +#define apmmode (G.apmmode ) +#define get_IDentity (G.get_IDentity ) +#define set_busstate (G.set_busstate ) +#define get_busstate (G.get_busstate ) +#define perform_reset (G.perform_reset ) +#define perform_tristate (G.perform_tristate ) +#define unregister_hwif (G.unregister_hwif ) +#define scan_hwif (G.scan_hwif ) +#define busstate (G.busstate ) +#define tristate (G.tristate ) +#define hwif (G.hwif ) +#define hwif_data (G.hwif_data ) +#define hwif_ctrl (G.hwif_ctrl ) +#define hwif_irq (G.hwif_irq ) + + +/* Busybox messages and functions */ +#if ENABLE_IOCTL_HEX2STR_ERROR +static int ioctl_alt_func(/*int fd,*/ int cmd, unsigned char *args, int alt, const char *string) +{ + if (!ioctl(fd, cmd, args)) + return 0; + args[0] = alt; + return bb_ioctl_or_warn(fd, cmd, args, string); +} +#define ioctl_alt_or_warn(cmd,args,alt) ioctl_alt_func(cmd,args,alt,#cmd) +#else +static int ioctl_alt_func(/*int fd,*/ int cmd, unsigned char *args, int alt) +{ + if (!ioctl(fd, cmd, args)) + return 0; + args[0] = alt; + return bb_ioctl_or_warn(fd, cmd, args); +} +#define ioctl_alt_or_warn(cmd,args,alt) ioctl_alt_func(cmd,args,alt) +#endif + +static void on_off(int value) +{ + puts(value ? " (on)" : " (off)"); +} + +static void print_flag_on_off(int get_arg, const char *s, unsigned long arg) +{ + if (get_arg) { + printf(" setting %s to %ld", s, arg); + on_off(arg); } - return err_dma; } -static void print_ascii(uint16_t *p, uint8_t length) { - uint8_t ii; - char cl; - + +static void print_value_on_off(const char *str, unsigned long argp) +{ + printf(" %s\t= %2ld", str, argp); + on_off(argp != 0); +} + +#if ENABLE_FEATURE_HDPARM_GET_IDENTITY +static void print_ascii(const char *p, int length) +{ +#if BB_BIG_ENDIAN +#define LE_ONLY(x) + enum { ofs = 0 }; +#else +#define LE_ONLY(x) x + /* every 16bit word is big-endian (i.e. inverted) */ + /* accessing bytes in 1,0, 3,2, 5,4... sequence */ + int ofs = 1; +#endif + + length *= 2; /* find first non-space & print it */ - for(ii = 0; ii< length; ii++) { - if(((char) 0x00ff&((*p)>>8)) != ' ') break; - if((cl = (char) 0x00ff&(*p)) != ' ') { - if(cl != '\0') printf("%c",cl); - p++; ii++; - break; - } + while (length && p[ofs] != ' ') { p++; + LE_ONLY(ofs = -ofs;) + length--; } - /* print the rest */ - for(; ii< length; ii++) { - if(!(*p)) break; /* some older devices have NULLs */ - printf("%c%c",(char)0x00ff&((*p)>>8),(char)(*p)&0x00ff); + while (length && p[ofs]) { + bb_putchar(p[ofs]); p++; + LE_ONLY(ofs = -ofs;) + length--; } - printf("\n"); + bb_putchar('\n'); +#undef LE_ONLY } -/* identify() is the only extern function used across two source files. The - others, though, were declared in hdparm.c with global scope; since other - functions in that file have static (file) scope, I assume the difference is - intentional. */ -static void identify (uint16_t *id_supplied, const char *devname) +static void xprint_ascii(uint16_t *val, int i, const char *string, int n) { + if (val[i]) { + printf("\t%-20s", string); + print_ascii((void*)&val[i], n); + } +} - char *id_file = NULL, fmt[]="/proc/ide/%s/identify"; - FILE *fl; - uint16_t val[256], ii, jj, kk; +static uint8_t mode_loop(uint16_t mode_sup, uint16_t mode_sel, int cc, uint8_t *have_mode) +{ + uint16_t ii; + uint8_t err_dma = 0; + + for (ii = 0; ii <= MODE_MAX; ii++) { + if (mode_sel & 0x0001) { + printf("*%cdma%u ", cc, ii); + if (*have_mode) + err_dma = 1; + *have_mode = 1; + } else if (mode_sup & 0x0001) + printf("%cdma%u ", cc, ii); + + mode_sup >>= 1; + mode_sel >>= 1; + } + return err_dma; +} + +static const char pkt_str[] ALIGN1 = + "Direct-access device" "\0" /* word 0, bits 12-8 = 00 */ + "Sequential-access device" "\0" /* word 0, bits 12-8 = 01 */ + "Printer" "\0" /* word 0, bits 12-8 = 02 */ + "Processor" "\0" /* word 0, bits 12-8 = 03 */ + "Write-once device" "\0" /* word 0, bits 12-8 = 04 */ + "CD-ROM" "\0" /* word 0, bits 12-8 = 05 */ + "Scanner" "\0" /* word 0, bits 12-8 = 06 */ + "Optical memory" "\0" /* word 0, bits 12-8 = 07 */ + "Medium changer" "\0" /* word 0, bits 12-8 = 08 */ + "Communications device" "\0" /* word 0, bits 12-8 = 09 */ + "ACS-IT8 device" "\0" /* word 0, bits 12-8 = 0a */ + "ACS-IT8 device" "\0" /* word 0, bits 12-8 = 0b */ + "Array controller" "\0" /* word 0, bits 12-8 = 0c */ + "Enclosure services" "\0" /* word 0, bits 12-8 = 0d */ + "Reduced block command device" "\0" /* word 0, bits 12-8 = 0e */ + "Optical card reader/writer" "\0" /* word 0, bits 12-8 = 0f */ +; + +static const char ata1_cfg_str[] ALIGN1 = /* word 0 in ATA-1 mode */ + "reserved" "\0" /* bit 0 */ + "hard sectored" "\0" /* bit 1 */ + "soft sectored" "\0" /* bit 2 */ + "not MFM encoded " "\0" /* bit 3 */ + "head switch time > 15us" "\0" /* bit 4 */ + "spindle motor control option" "\0" /* bit 5 */ + "fixed drive" "\0" /* bit 6 */ + "removable drive" "\0" /* bit 7 */ + "disk xfer rate <= 5Mbs" "\0" /* bit 8 */ + "disk xfer rate > 5Mbs, <= 10Mbs" "\0" /* bit 9 */ + "disk xfer rate > 5Mbs" "\0" /* bit 10 */ + "rotational speed tol." "\0" /* bit 11 */ + "data strobe offset option" "\0" /* bit 12 */ + "track offset option" "\0" /* bit 13 */ + "format speed tolerance gap reqd" "\0" /* bit 14 */ + "ATAPI" /* bit 14 */ +; + +static const char minor_str[] ALIGN1 = + /* word 81 value: */ + "Unspecified" "\0" /* 0x0000 */ + "ATA-1 X3T9.2 781D prior to rev.4" "\0" /* 0x0001 */ + "ATA-1 published, ANSI X3.221-1994" "\0" /* 0x0002 */ + "ATA-1 X3T9.2 781D rev.4" "\0" /* 0x0003 */ + "ATA-2 published, ANSI X3.279-1996" "\0" /* 0x0004 */ + "ATA-2 X3T10 948D prior to rev.2k" "\0" /* 0x0005 */ + "ATA-3 X3T10 2008D rev.1" "\0" /* 0x0006 */ + "ATA-2 X3T10 948D rev.2k" "\0" /* 0x0007 */ + "ATA-3 X3T10 2008D rev.0" "\0" /* 0x0008 */ + "ATA-2 X3T10 948D rev.3" "\0" /* 0x0009 */ + "ATA-3 published, ANSI X3.298-199x" "\0" /* 0x000a */ + "ATA-3 X3T10 2008D rev.6" "\0" /* 0x000b */ + "ATA-3 X3T13 2008D rev.7 and 7a" "\0" /* 0x000c */ + "ATA/ATAPI-4 X3T13 1153D rev.6" "\0" /* 0x000d */ + "ATA/ATAPI-4 T13 1153D rev.13" "\0" /* 0x000e */ + "ATA/ATAPI-4 X3T13 1153D rev.7" "\0" /* 0x000f */ + "ATA/ATAPI-4 T13 1153D rev.18" "\0" /* 0x0010 */ + "ATA/ATAPI-4 T13 1153D rev.15" "\0" /* 0x0011 */ + "ATA/ATAPI-4 published, ANSI INCITS 317-1998" "\0" /* 0x0012 */ + "ATA/ATAPI-5 T13 1321D rev.3" "\0" /* 0x0013 */ + "ATA/ATAPI-4 T13 1153D rev.14" "\0" /* 0x0014 */ + "ATA/ATAPI-5 T13 1321D rev.1" "\0" /* 0x0015 */ + "ATA/ATAPI-5 published, ANSI INCITS 340-2000" "\0" /* 0x0016 */ + "ATA/ATAPI-4 T13 1153D rev.17" "\0" /* 0x0017 */ + "ATA/ATAPI-6 T13 1410D rev.0" "\0" /* 0x0018 */ + "ATA/ATAPI-6 T13 1410D rev.3a" "\0" /* 0x0019 */ + "ATA/ATAPI-7 T13 1532D rev.1" "\0" /* 0x001a */ + "ATA/ATAPI-6 T13 1410D rev.2" "\0" /* 0x001b */ + "ATA/ATAPI-6 T13 1410D rev.1" "\0" /* 0x001c */ + "ATA/ATAPI-7 published, ANSI INCITS 397-2005" "\0" /* 0x001d */ + "ATA/ATAPI-7 T13 1532D rev.0" "\0" /* 0x001e */ + "reserved" "\0" /* 0x001f */ + "reserved" "\0" /* 0x0020 */ + "ATA/ATAPI-7 T13 1532D rev.4a" "\0" /* 0x0021 */ + "ATA/ATAPI-6 published, ANSI INCITS 361-2002" "\0" /* 0x0022 */ + "reserved" /* 0x0023-0xfffe */ +; +static const char actual_ver[MINOR_MAX + 2] ALIGN1 = { + /* word 81 value: */ + 0, /* 0x0000 WARNING: actual_ver[] array */ + 1, /* 0x0001 WARNING: corresponds */ + 1, /* 0x0002 WARNING: *exactly* */ + 1, /* 0x0003 WARNING: to the ATA/ */ + 2, /* 0x0004 WARNING: ATAPI version */ + 2, /* 0x0005 WARNING: listed in */ + 3, /* 0x0006 WARNING: the */ + 2, /* 0x0007 WARNING: minor_str */ + 3, /* 0x0008 WARNING: array */ + 2, /* 0x0009 WARNING: above. */ + 3, /* 0x000a WARNING: */ + 3, /* 0x000b WARNING: If you change */ + 3, /* 0x000c WARNING: that one, */ + 4, /* 0x000d WARNING: change this one */ + 4, /* 0x000e WARNING: too!!! */ + 4, /* 0x000f */ + 4, /* 0x0010 */ + 4, /* 0x0011 */ + 4, /* 0x0012 */ + 5, /* 0x0013 */ + 4, /* 0x0014 */ + 5, /* 0x0015 */ + 5, /* 0x0016 */ + 4, /* 0x0017 */ + 6, /* 0x0018 */ + 6, /* 0x0019 */ + 7, /* 0x001a */ + 6, /* 0x001b */ + 6, /* 0x001c */ + 7, /* 0x001d */ + 7, /* 0x001e */ + 0, /* 0x001f */ + 0, /* 0x0020 */ + 7, /* 0x0021 */ + 6, /* 0x0022 */ + 0 /* 0x0023-0xfffe */ +}; + +static const char cmd_feat_str[] ALIGN1 = + "" "\0" /* word 82 bit 15: obsolete */ + "NOP cmd" "\0" /* word 82 bit 14 */ + "READ BUFFER cmd" "\0" /* word 82 bit 13 */ + "WRITE BUFFER cmd" "\0" /* word 82 bit 12 */ + "" "\0" /* word 82 bit 11: obsolete */ + "Host Protected Area feature set" "\0" /* word 82 bit 10 */ + "DEVICE RESET cmd" "\0" /* word 82 bit 9 */ + "SERVICE interrupt" "\0" /* word 82 bit 8 */ + "Release interrupt" "\0" /* word 82 bit 7 */ + "Look-ahead" "\0" /* word 82 bit 6 */ + "Write cache" "\0" /* word 82 bit 5 */ + "PACKET command feature set" "\0" /* word 82 bit 4 */ + "Power Management feature set" "\0" /* word 82 bit 3 */ + "Removable Media feature set" "\0" /* word 82 bit 2 */ + "Security Mode feature set" "\0" /* word 82 bit 1 */ + "SMART feature set" "\0" /* word 82 bit 0 */ + /* -------------- */ + "" "\0" /* word 83 bit 15: !valid bit */ + "" "\0" /* word 83 bit 14: valid bit */ + "FLUSH CACHE EXT cmd" "\0" /* word 83 bit 13 */ + "Mandatory FLUSH CACHE cmd " "\0" /* word 83 bit 12 */ + "Device Configuration Overlay feature set " "\0" + "48-bit Address feature set " "\0" /* word 83 bit 10 */ + "" "\0" + "SET MAX security extension" "\0" /* word 83 bit 8 */ + "Address Offset Reserved Area Boot" "\0" /* word 83 bit 7 */ + "SET FEATURES subcommand required to spinup after power up" "\0" + "Power-Up In Standby feature set" "\0" /* word 83 bit 5 */ + "Removable Media Status Notification feature set" "\0" + "Adv. Power Management feature set" "\0" /* word 83 bit 3 */ + "CFA feature set" "\0" /* word 83 bit 2 */ + "READ/WRITE DMA QUEUED" "\0" /* word 83 bit 1 */ + "DOWNLOAD MICROCODE cmd" "\0" /* word 83 bit 0 */ + /* -------------- */ + "" "\0" /* word 84 bit 15: !valid bit */ + "" "\0" /* word 84 bit 14: valid bit */ + "" "\0" /* word 84 bit 13: reserved */ + "" "\0" /* word 84 bit 12: reserved */ + "" "\0" /* word 84 bit 11: reserved */ + "" "\0" /* word 84 bit 10: reserved */ + "" "\0" /* word 84 bit 9: reserved */ + "" "\0" /* word 84 bit 8: reserved */ + "" "\0" /* word 84 bit 7: reserved */ + "" "\0" /* word 84 bit 6: reserved */ + "General Purpose Logging feature set" "\0" /* word 84 bit 5 */ + "" "\0" /* word 84 bit 4: reserved */ + "Media Card Pass Through Command feature set " "\0" + "Media serial number " "\0" /* word 84 bit 2 */ + "SMART self-test " "\0" /* word 84 bit 1 */ + "SMART error logging " /* word 84 bit 0 */ +; + +static const char secu_str[] ALIGN1 = + "supported" "\0" /* word 128, bit 0 */ + "enabled" "\0" /* word 128, bit 1 */ + "locked" "\0" /* word 128, bit 2 */ + "frozen" "\0" /* word 128, bit 3 */ + "expired: security count" "\0" /* word 128, bit 4 */ + "supported: enhanced erase" /* word 128, bit 5 */ +; + +// Parse 512 byte disk identification block and print much crap. +static void identify(uint16_t *val) NORETURN; +static void identify(uint16_t *val) +{ + uint16_t ii, jj, kk; uint16_t like_std = 1, std = 0, min_std = 0xffff; uint16_t dev = NO_DEV, eqpt = NO_DEV; uint8_t have_mode = 0, err_dma = 0; uint8_t chksum = 0; uint32_t ll, mm, nn, oo; - __u64 bbbig; /* (:) */ - - if (id_supplied) { -#if __BYTE_ORDER == __BIG_ENDIAN - swab(id_supplied, val, sizeof(val)); -#else - memcpy(val, id_supplied, sizeof(val)); + uint64_t bbbig; /* (:) */ + const char *strng; +#if BB_BIG_ENDIAN + uint16_t buf[256]; + + // Adjust for endianness + swab(val, buf, sizeof(buf)); + val = buf; #endif - } else { - id_file = xcalloc(1, strlen(devname)+1+strlen(fmt)); - sprintf(id_file, fmt, devname); - - /* open the file, read in all the info and close it */ - if (id_file == NULL) { - fl = stdin; - } else if(NULL == (fl = fopen(id_file, "r"))) - bb_perror_msg_and_die(id_file); - /* calculate checksum over all bytes */ - for(ii = GEN_CONFIG; ii<=INTEGRITY; ii++) { - unsigned int scratch; - if(1 != fscanf(fl,"%04x",&scratch)) break; - val[ii] = (uint16_t)scratch; - chksum += val[ii] + (val[ii] >> 8); - } - fclose(fl); - if(ii < (INTEGRITY+1)) - bb_error_msg_and_die("Input file wrong format or length"); - } - chksum &= 0xff; - /* check if we recognise the device type */ - printf("\n"); - if(!(val[GEN_CONFIG] & NOT_ATA)) { + bb_putchar('\n'); + if (!(val[GEN_CONFIG] & NOT_ATA)) { dev = ATA_DEV; printf("ATA device, with "); - } else if(val[GEN_CONFIG]==CFA_SUPPORT_VAL) { + } else if (val[GEN_CONFIG]==CFA_SUPPORT_VAL) { dev = ATA_DEV; like_std = 4; printf("CompactFlash ATA device, with "); - } else if(!(val[GEN_CONFIG] & NOT_ATAPI)) { + } else if (!(val[GEN_CONFIG] & NOT_ATAPI)) { dev = ATAPI_DEV; eqpt = (val[GEN_CONFIG] & EQPT_TYPE) >> SHIFT_EQPT; - printf("ATAPI %s, with ", pkt_str[eqpt]); + printf("ATAPI %s, with ", eqpt <= 0xf ? nth_string(pkt_str, eqpt) : "unknown"); like_std = 3; - } else { - bb_error_msg_and_die("Unknown device type:\n\tbits 15&14 of general configuration word 0 both set to 1.\n"); - } - if(!(val[GEN_CONFIG] & MEDIA_REMOVABLE)) - printf("non-"); - printf("removable media\n"); - + } else + /* "Unknown device type:\n\tbits 15&14 of general configuration word 0 both set to 1.\n" */ + bb_error_msg_and_die("unknown device type"); + printf("%sremovable media\n", !(val[GEN_CONFIG] & MEDIA_REMOVABLE) ? "non-" : ""); /* Info from the specific configuration word says whether or not the * ID command completed correctly. It is only defined, however in - * ATA/ATAPI-5 & 6; it is reserved (value theoretically 0) in prior + * ATA/ATAPI-5 & 6; it is reserved (value theoretically 0) in prior * standards. Since the values allowed for this word are extremely * specific, it should be safe to check it now, even though we don't * know yet what standard this device is using. */ - if((val[CONFIG]==STBY_NID_VAL) || (val[CONFIG]==STBY_ID_VAL) || - (val[CONFIG]==PWRD_NID_VAL) || (val[CONFIG]==PWRD_ID_VAL) ) { - like_std = 5; - if((val[CONFIG]==STBY_NID_VAL) || (val[CONFIG]==STBY_ID_VAL)) + if ((val[CONFIG]==STBY_NID_VAL) || (val[CONFIG]==STBY_ID_VAL) + || (val[CONFIG]==PWRD_NID_VAL) || (val[CONFIG]==PWRD_ID_VAL) + ) { + like_std = 5; + if ((val[CONFIG]==STBY_NID_VAL) || (val[CONFIG]==STBY_ID_VAL)) printf("powers-up in standby; SET FEATURES subcmd spins-up.\n"); - if(((val[CONFIG]==STBY_NID_VAL) || (val[CONFIG]==PWRD_NID_VAL)) && - (val[GEN_CONFIG] & INCOMPLETE)) - printf("\n\tWARNING: ID response incomplete.\n\tWARNING: Following data may be incorrect.\n\n"); + if (((val[CONFIG]==STBY_NID_VAL) || (val[CONFIG]==PWRD_NID_VAL)) && (val[GEN_CONFIG] & INCOMPLETE)) + printf("\n\tWARNING: ID response incomplete.\n\tFollowing data may be incorrect.\n\n"); } /* output the model and serial numbers and the fw revision */ - if(val[START_MODEL]) { - printf("\t%-20s","Model Number:"); - print_ascii(&val[START_MODEL], LENGTH_MODEL); - } - if(val[START_SERIAL]) { - printf("\t%-20s","Serial Number:"); - print_ascii( &val[START_SERIAL], LENGTH_SERIAL); - } - if(val[START_FW_REV]) { - printf("\t%-20s","Firmware Revision:"); - print_ascii(&val[START_FW_REV], LENGTH_FW_REV); - } - if(val[START_MEDIA]) { - printf("\t%-20s","Media Serial Num:"); - print_ascii(&val[START_MEDIA], LENGTH_MEDIA); - } - if(val[START_MANUF]) { - printf("\t%-20s","Media Manufacturer:"); - print_ascii(&val[START_MANUF], LENGTH_MANUF); - } + xprint_ascii(val, START_MODEL, "Model Number:", LENGTH_MODEL); + xprint_ascii(val, START_SERIAL, "Serial Number:", LENGTH_SERIAL); + xprint_ascii(val, START_FW_REV, "Firmware Revision:", LENGTH_FW_REV); + xprint_ascii(val, START_MEDIA, "Media Serial Num:", LENGTH_MEDIA); + xprint_ascii(val, START_MANUF, "Media Manufacturer:", LENGTH_MANUF); /* major & minor standards version number (Note: these words were not * defined until ATA-3 & the CDROM std uses different words.) */ printf("Standards:"); - if(eqpt != CDROM) { - if(val[MINOR] && (val[MINOR] <= MINOR_MAX)){ - if(like_std < 3) like_std = 3; + if (eqpt != CDROM) { + if (val[MINOR] && (val[MINOR] <= MINOR_MAX)) { + if (like_std < 3) like_std = 3; std = actual_ver[val[MINOR]]; - if(std) { - printf("\n\tUsed: "); - printf("%s ",minor_str[val[MINOR]]); - } + if (std) printf("\n\tUsed: %s ", nth_string(minor_str, val[MINOR])); + } /* looks like when they up-issue the std, they obsolete one; - * thus, only the newest 4 issues need be supported. (That's + * thus, only the newest 4 issues need be supported. (That's * what "kk" and "min_std" are all about.) */ - if(val[MAJOR] && (val[MAJOR] !=NOVAL_1)) { + if (val[MAJOR] && (val[MAJOR] != NOVAL_1)) { printf("\n\tSupported: "); jj = val[MAJOR] << 1; kk = like_std >4 ? like_std-4: 0; - for(ii = 14; (ii >0)&&(ii>kk); ii--) { - if(jj & 0x8000) { + for (ii = 14; (ii >0)&&(ii>kk); ii--) { + if (jj & 0x8000) { printf("%u ", ii); - if(like_std < ii) { + if (like_std < ii) { like_std = ii; kk = like_std >4 ? like_std-4: 0; } - if(min_std > ii) min_std = ii; + if (min_std > ii) min_std = ii; } jj <<= 1; } - if(like_std < 3) like_std = 3; + if (like_std < 3) like_std = 3; } /* Figure out what standard the device is using if it hasn't told * us. If we know the std, check if the device is using any of * the words from the next level up. It happens. */ - if(like_std < std) like_std = std; - if(((std == 5) || (!std && (like_std < 6))) && - ( (((val[CMDS_SUPP_1] & VALID) == VALID_VAL) && - ((val[CMDS_SUPP_1] & CMDS_W83) > 0x00ff)) || - (((val[CMDS_SUPP_2] & VALID) == VALID_VAL) && - (val[CMDS_SUPP_2] & CMDS_W84) ) ) ) { + if (like_std < std) like_std = std; + + if (((std == 5) || (!std && (like_std < 6))) && + ((((val[CMDS_SUPP_1] & VALID) == VALID_VAL) && + (( val[CMDS_SUPP_1] & CMDS_W83) > 0x00ff)) || + ((( val[CMDS_SUPP_2] & VALID) == VALID_VAL) && + ( val[CMDS_SUPP_2] & CMDS_W84) ) ) + ) { like_std = 6; - } else if(((std == 4) || (!std && (like_std < 5))) && - ((((val[INTEGRITY] & SIG) == SIG_VAL) && !chksum) || - ((val[HWRST_RSLT] & VALID) == VALID_VAL) || - (((val[CMDS_SUPP_1] & VALID) == VALID_VAL) && - ((val[CMDS_SUPP_1] & CMDS_W83) > 0x001f)) ) ) { + } else if (((std == 4) || (!std && (like_std < 5))) && + ((((val[INTEGRITY] & SIG) == SIG_VAL) && !chksum) || + (( val[HWRST_RSLT] & VALID) == VALID_VAL) || + ((( val[CMDS_SUPP_1] & VALID) == VALID_VAL) && + (( val[CMDS_SUPP_1] & CMDS_W83) > 0x001f)) ) ) + { like_std = 5; - } else if(((std == 3) || (!std && (like_std < 4))) && - ((((val[CMDS_SUPP_1] & VALID) == VALID_VAL) && - (((val[CMDS_SUPP_1] & CMDS_W83) > 0x0000) || - ((val[CMDS_SUPP_0] & CMDS_W82) > 0x000f))) || - ((val[CAPAB_1] & VALID) == VALID_VAL) || - ((val[WHATS_VALID] & OK_W88) && val[ULTRA_DMA]) || - ((val[RM_STAT] & RM_STAT_BITS) == RM_STAT_SUP) ) ) { + } else if (((std == 3) || (!std && (like_std < 4))) && + ((((val[CMDS_SUPP_1] & VALID) == VALID_VAL) && + ((( val[CMDS_SUPP_1] & CMDS_W83) > 0x0000) || + (( val[CMDS_SUPP_0] & CMDS_W82) > 0x000f))) || + (( val[CAPAB_1] & VALID) == VALID_VAL) || + (( val[WHATS_VALID] & OK_W88) && val[ULTRA_DMA]) || + (( val[RM_STAT] & RM_STAT_BITS) == RM_STAT_SUP) ) + ) { like_std = 4; - } else if(((std == 2) || (!std && (like_std < 3))) && - ((val[CMDS_SUPP_1] & VALID) == VALID_VAL) ) { + } else if (((std == 2) || (!std && (like_std < 3))) + && ((val[CMDS_SUPP_1] & VALID) == VALID_VAL) + ) { like_std = 3; - } else if(((std == 1) || (!std && (like_std < 2))) && - ((val[CAPAB_0] & (IORDY_SUP | IORDY_OFF)) || - (val[WHATS_VALID] & OK_W64_70)) ) { + } else if (((std == 1) || (!std && (like_std < 2))) && + ((val[CAPAB_0] & (IORDY_SUP | IORDY_OFF)) || + (val[WHATS_VALID] & OK_W64_70)) ) + { like_std = 2; } - if(!std) { - printf("\n\tLikely used: %u\n",like_std); - } else if(like_std > std) { - printf("& some of %u\n",like_std); - } else printf("\n"); + + if (!std) + printf("\n\tLikely used: %u\n", like_std); + else if (like_std > std) + printf("& some of %u\n", like_std); + else + bb_putchar('\n'); } else { /* TBD: do CDROM stuff more thoroughly. For now... */ - kk = 0; - if(val[CDR_MINOR] == 9) { + kk = 0; + if (val[CDR_MINOR] == 9) { kk = 1; printf("\n\tUsed: ATAPI for CD-ROMs, SFF-8020i, r2.5"); } - if(val[CDR_MAJOR] && (val[CDR_MAJOR] !=NOVAL_1)) { + if (val[CDR_MAJOR] && (val[CDR_MAJOR] !=NOVAL_1)) { kk = 1; printf("\n\tSupported: CD-ROM ATAPI"); jj = val[CDR_MAJOR] >> 1; - for(ii = 1; ii <15; ii++) { - if(jj & 0x0001) { - printf("-%u ", ii); - } + for (ii = 1; ii < 15; ii++) { + if (jj & 0x0001) printf("-%u ", ii); jj >>= 1; } } - if(!kk) printf("\n\tLikely used CD-ROM ATAPI-1\n"); - else printf("\n"); + puts(kk ? "" : "\n\tLikely used CD-ROM ATAPI-1"); /* the cdrom stuff is more like ATA-2 than anything else, so: */ like_std = 2; } - if(min_std == 0xffff) min_std = like_std > 4 ? like_std - 3 : 1; + if (min_std == 0xffff) + min_std = like_std > 4 ? like_std - 3 : 1; printf("Configuration:\n"); /* more info from the general configuration word */ - if((eqpt != CDROM) && (like_std == 1)) { + if ((eqpt != CDROM) && (like_std == 1)) { jj = val[GEN_CONFIG] >> 1; - for(ii = 1; ii < 15; ii++) { - if(jj & 0x0001) printf("\t%s\n",ata1_cfg_str[ii]); + for (ii = 1; ii < 15; ii++) { + if (jj & 0x0001) + printf("\t%s\n", nth_string(ata1_cfg_str, ii)); jj >>=1; } } - if(dev == ATAPI_DEV) { - printf("\tDRQ response: "); /* Data Request (DRQ) */ - switch(val[GEN_CONFIG] & DRQ_RESPONSE_TIME) { - case DRQ_3MS_VAL : printf("3ms.\n"); break; - case DRQ_INTR_VAL : printf("<=10ms with INTRQ\n"); break; - case DRQ_50US_VAL : printf("50us.\n"); break; - default : printf("unknown.\n"); break; - } - printf("\tPacket size: "); - switch(val[GEN_CONFIG] & PKT_SIZE_SUPPORTED) { - case PKT_SIZE_12_VAL : printf("12 bytes\n"); break; - case PKT_SIZE_16_VAL : printf("16 bytes\n"); break; - default : printf("Unknown\n"); break; - } + if (dev == ATAPI_DEV) { + if ((val[GEN_CONFIG] & DRQ_RESPONSE_TIME) == DRQ_3MS_VAL) + strng = "3ms"; + else if ((val[GEN_CONFIG] & DRQ_RESPONSE_TIME) == DRQ_INTR_VAL) + strng = "<=10ms with INTRQ"; + else if ((val[GEN_CONFIG] & DRQ_RESPONSE_TIME) == DRQ_50US_VAL) + strng ="50us"; + else + strng = "unknown"; + printf("\tDRQ response: %s\n\tPacket size: ", strng); /* Data Request (DRQ) */ + + if ((val[GEN_CONFIG] & PKT_SIZE_SUPPORTED) == PKT_SIZE_12_VAL) + strng = "12 bytes"; + else if ((val[GEN_CONFIG] & PKT_SIZE_SUPPORTED) == PKT_SIZE_16_VAL) + strng = "16 bytes"; + else + strng = "unknown"; + puts(strng); } else { - /* addressing...CHS? See section 6.2 of ATA specs 4 or 5 */ + /* addressing...CHS? See section 6.2 of ATA specs 4 or 5 */ ll = (uint32_t)val[LBA_SECTS_MSB] << 16 | val[LBA_SECTS_LSB]; mm = 0; bbbig = 0; - if ( (ll > 0x00FBFC10) && (!val[LCYLS])) { - printf("\tCHS addressing not supported\n"); - } else { + if ((ll > 0x00FBFC10) && (!val[LCYLS])) + printf("\tCHS addressing not supported\n"); + else { jj = val[WHATS_VALID] & OK_W54_58; - printf("\tLogical\t\tmax\tcurrent\n"); - printf("\tcylinders\t%u\t%u\n",val[LCYLS],jj?val[LCYLS_CUR]:0); - printf("\theads\t\t%u\t%u\n",val[LHEADS],jj?val[LHEADS_CUR]:0); - printf("\tsectors/track\t%u\t%u\n",val[LSECTS],jj?val[LSECTS_CUR]:0); - printf("\t--\n"); - if((min_std == 1) && (val[TRACK_BYTES] || val[SECT_BYTES])) { - printf("\tbytes/track: %u",val[TRACK_BYTES]); - printf("\tbytes/sector: %u\n",val[SECT_BYTES]); - } - if(jj) { + printf("\tLogical\t\tmax\tcurrent\n\tcylinders\t%u\t%u\n\theads\t\t%u\t%u\n\tsectors/track\t%u\t%u\n\t--\n", + val[LCYLS],jj?val[LCYLS_CUR]:0, val[LHEADS],jj?val[LHEADS_CUR]:0, val[LSECTS],jj?val[LSECTS_CUR]:0); + + if ((min_std == 1) && (val[TRACK_BYTES] || val[SECT_BYTES])) + printf("\tbytes/track: %u\tbytes/sector: %u\n", val[TRACK_BYTES], val[SECT_BYTES]); + + if (jj) { mm = (uint32_t)val[CAPACITY_MSB] << 16 | val[CAPACITY_LSB]; - if(like_std < 3) { /* check Endian of capacity bytes */ + if (like_std < 3) { + /* check Endian of capacity bytes */ nn = val[LCYLS_CUR] * val[LHEADS_CUR] * val[LSECTS_CUR]; oo = (uint32_t)val[CAPACITY_LSB] << 16 | val[CAPACITY_MSB]; - if(abs(mm - nn) > abs(oo - nn)) + if (abs(mm - nn) > abs(oo - nn)) mm = oo; } - printf("\tCHS current addressable sectors:%11u\n",mm); - } + printf("\tCHS current addressable sectors:%11u\n", mm); + } } /* LBA addressing */ - printf("\tLBA user addressable sectors:%11u\n",ll); - if( ((val[CMDS_SUPP_1] & VALID) == VALID_VAL) && - (val[CMDS_SUPP_1] & SUPPORT_48_BIT) ) { - bbbig = (__u64)val[LBA_64_MSB] << 48 | - (__u64)val[LBA_48_MSB] << 32 | - (__u64)val[LBA_MID] << 16 | - val[LBA_LSB] ; - printf("\tLBA48 user addressable sectors:%11llu\n",bbbig); - } - if (!bbbig) bbbig = (__u64)(ll>mm ? ll : mm); /* # 512 byte blocks */ - printf("\tdevice size with M = 1024*1024: %11llu MBytes\n",bbbig>>11); - bbbig = (bbbig<<9)/1000000; - printf("\tdevice size with M = 1000*1000: %11llu MBytes ",bbbig); - if(bbbig > 1000) printf("(%llu GB)\n",bbbig/1000); - else printf("\n"); - + printf("\tLBA user addressable sectors:%11u\n", ll); + if (((val[CMDS_SUPP_1] & VALID) == VALID_VAL) + && (val[CMDS_SUPP_1] & SUPPORT_48_BIT) + ) { + bbbig = (uint64_t)val[LBA_64_MSB] << 48 | + (uint64_t)val[LBA_48_MSB] << 32 | + (uint64_t)val[LBA_MID] << 16 | + val[LBA_LSB]; + printf("\tLBA48 user addressable sectors:%11"PRIu64"\n", bbbig); + } + + if (!bbbig) + bbbig = (uint64_t)(ll>mm ? ll : mm); /* # 512 byte blocks */ + printf("\tdevice size with M = 1024*1024: %11"PRIu64" MBytes\n", bbbig>>11); + bbbig = (bbbig << 9) / 1000000; + printf("\tdevice size with M = 1000*1000: %11"PRIu64" MBytes ", bbbig); + + if (bbbig > 1000) + printf("(%"PRIu64" GB)\n", bbbig/1000); + else + bb_putchar('\n'); } /* hw support of commands (capabilities) */ - printf("Capabilities:\n"); - printf("\t"); - if(dev == ATAPI_DEV) { - if(eqpt != CDROM) { - if(val[CAPAB_0] & CMD_Q_SUP) printf("Cmd queuing, "); - } - if(val[CAPAB_0] & OVLP_SUP) printf("Cmd overlap, "); - } - if(val[CAPAB_0] & LBA_SUP) printf("LBA, "); - if(like_std != 1) { - printf("IORDY"); - if(!(val[CAPAB_0] & IORDY_SUP)) printf("(may be)"); - if(val[CAPAB_0] & IORDY_OFF) printf("(can"); - else printf("(cannot"); - printf(" be disabled)"); - } else printf("no IORDY"); - printf("\n"); - if((like_std == 1) && val[BUF_TYPE]) { - kk = val[BUF_TYPE]; - printf("\tBuffer type: %04x: ",kk); - if (kk < 2) printf("single port, single-sector"); - else printf("dual port, multi-sector"); - if (kk > 2) printf(" with read caching ability"); - printf("\n"); - } - jj = 0; - if((min_std == 1) && (val[BUFFER__SIZE] && (val[BUFFER__SIZE] != NOVAL_1))) { - printf("\tBuffer size: %.1fkB",(float)val[BUFFER__SIZE]/2); - jj = 1; - } - if((min_std < 4) && (val[RW_LONG])) { - printf("\tbytes avail on r/w long: %u",val[RW_LONG]); - jj = 1; - } - if((eqpt != CDROM) && (like_std > 3)) { - printf("\tQueue depth: %u",(val[QUEUE_DEPTH] & DEPTH_BITS)+1); - jj = 1; - } - if(jj) printf("\n"); - if(dev == ATA_DEV) { - if(like_std == 1) { - printf("\tCan"); - if(!val[DWORD_IO]) printf("not"); - printf(" perform double-word IO\n"); - } else { - printf("\tStandby timer values: spec'd by "); - if(val[CAPAB_0] & STD_STBY) printf("Standard"); - else printf("Vendor"); - if((like_std > 3) && ((val[CAPAB_1] & VALID) == VALID_VAL)) { - if(val[CAPAB_1] & MIN_STANDBY_TIMER) printf(", with "); - else printf(", no "); - printf("device specific minimum\n"); - } else printf("\n"); + printf("Capabilities:\n\t"); + + if (dev == ATAPI_DEV) { + if (eqpt != CDROM && (val[CAPAB_0] & CMD_Q_SUP)) printf("Cmd queuing, "); + if (val[CAPAB_0] & OVLP_SUP) printf("Cmd overlap, "); + } + if (val[CAPAB_0] & LBA_SUP) printf("LBA, "); + + if (like_std != 1) { + printf("IORDY%s(can%s be disabled)\n", + !(val[CAPAB_0] & IORDY_SUP) ? "(may be)" : "", + (val[CAPAB_0] & IORDY_OFF) ? "" :"not"); + } else + printf("no IORDY\n"); + + if ((like_std == 1) && val[BUF_TYPE]) { + printf("\tBuffer type: %04x: %s%s\n", val[BUF_TYPE], + (val[BUF_TYPE] < 2) ? "single port, single-sector" : "dual port, multi-sector", + (val[BUF_TYPE] > 2) ? " with read caching ability" : ""); + } + + if ((min_std == 1) && (val[BUFFER__SIZE] && (val[BUFFER__SIZE] != NOVAL_1))) { + printf("\tBuffer size: %.1fkB\n", (float)val[BUFFER__SIZE]/2); + } + if ((min_std < 4) && (val[RW_LONG])) { + printf("\tbytes avail on r/w long: %u\n", val[RW_LONG]); + } + if ((eqpt != CDROM) && (like_std > 3)) { + printf("\tQueue depth: %u\n", (val[QUEUE_DEPTH] & DEPTH_BITS) + 1); + } + + if (dev == ATA_DEV) { + if (like_std == 1) + printf("\tCan%s perform double-word IO\n", (!val[DWORD_IO]) ? "not" : ""); + else { + printf("\tStandby timer values: spec'd by %s", (val[CAPAB_0] & STD_STBY) ? "Standard" : "Vendor"); + if ((like_std > 3) && ((val[CAPAB_1] & VALID) == VALID_VAL)) + printf(", %s device specific minimum\n", (val[CAPAB_1] & MIN_STANDBY_TIMER) ? "with" : "no"); + else + bb_putchar('\n'); } printf("\tR/W multiple sector transfer: "); - if((like_std < 3) && !(val[SECTOR_XFER_MAX] & SECTOR_XFER)) { + if ((like_std < 3) && !(val[SECTOR_XFER_MAX] & SECTOR_XFER)) printf("not supported\n"); - } else { - printf("Max = %u\t",val[SECTOR_XFER_MAX] & SECTOR_XFER); - printf("Current = "); - if(val[SECTOR_XFER_CUR] & MULTIPLE_SETTING_VALID) - printf("%u\n",val[SECTOR_XFER_CUR] & SECTOR_XFER); - else printf("?\n"); + else { + printf("Max = %u\tCurrent = ", val[SECTOR_XFER_MAX] & SECTOR_XFER); + if (val[SECTOR_XFER_CUR] & MULTIPLE_SETTING_VALID) + printf("%u\n", val[SECTOR_XFER_CUR] & SECTOR_XFER); + else + printf("?\n"); } - if((like_std > 3) && (val[CMDS_SUPP_1] & 0x0008)) { + if ((like_std > 3) && (val[CMDS_SUPP_1] & 0x0008)) { /* We print out elsewhere whether the APM feature is enabled or not. If it's not enabled, let's not repeat the info; just print nothing here. */ - printf("\tAdvanced power management level: "); - if ( (val[ADV_PWR] & 0xFF00) == 0x4000 ) { + printf("\tAdvancedPM level: "); + if ((val[ADV_PWR] & 0xFF00) == 0x4000) { uint8_t apm_level = val[ADV_PWR] & 0x00FF; - printf("%u (0x%x)\n", apm_level, apm_level); - } else { - printf("unknown setting (0x%04x)\n", val[ADV_PWR]); - } - } - if(like_std > 5) { - if(val[ACOUSTIC]) { - printf("\tRecommended acoustic management value: %u, current value: %u\n", (val[ACOUSTIC] >> 8) & 0x00ff, val[ACOUSTIC] & 0x00ff); } + else + printf("unknown setting (0x%04x)\n", val[ADV_PWR]); } - } else { /* ATAPI */ - if(eqpt != CDROM) { - if(val[CAPAB_0] & SWRST_REQ) printf("\tATA sw reset required\n"); + if (like_std > 5 && val[ACOUSTIC]) { + printf("\tRecommended acoustic management value: %u, current value: %u\n", + (val[ACOUSTIC] >> 8) & 0x00ff, val[ACOUSTIC] & 0x00ff); } - if(val[PKT_REL] || val[SVC_NBSY]) { + } else { + /* ATAPI */ + if (eqpt != CDROM && (val[CAPAB_0] & SWRST_REQ)) + printf("\tATA sw reset required\n"); + + if (val[PKT_REL] || val[SVC_NBSY]) { printf("\tOverlap support:"); - if(val[PKT_REL]) printf(" %uus to release bus.",val[PKT_REL]); - if(val[SVC_NBSY]) printf(" %uus to clear BSY after SERVICE cmd.",val[SVC_NBSY]); - printf("\n"); + if (val[PKT_REL]) printf(" %uus to release bus.", val[PKT_REL]); + if (val[SVC_NBSY]) printf(" %uus to clear BSY after SERVICE cmd.", val[SVC_NBSY]); + bb_putchar('\n'); } } /* DMA stuff. Check that only one DMA mode is selected. */ printf("\tDMA: "); - if(!(val[CAPAB_0] & DMA_SUP)) { + if (!(val[CAPAB_0] & DMA_SUP)) printf("not supported\n"); - } else { - if(val[DMA_MODE] && !val[SINGLE_DMA] && !val[MULTI_DMA]) - printf(" sdma%u\n",(val[DMA_MODE] & MODE) >> 8); - if(val[SINGLE_DMA]) { - jj = val[SINGLE_DMA]; kk = val[SINGLE_DMA] >> 8; - err_dma += mode_loop(jj,kk,'s',&have_mode); + else { + if (val[DMA_MODE] && !val[SINGLE_DMA] && !val[MULTI_DMA]) + printf(" sdma%u\n", (val[DMA_MODE] & MODE) >> 8); + if (val[SINGLE_DMA]) { + jj = val[SINGLE_DMA]; + kk = val[SINGLE_DMA] >> 8; + err_dma += mode_loop(jj, kk, 's', &have_mode); } - if(val[MULTI_DMA]) { - jj = val[MULTI_DMA]; kk = val[MULTI_DMA] >> 8; - err_dma += mode_loop(jj,kk,'m',&have_mode); + if (val[MULTI_DMA]) { + jj = val[MULTI_DMA]; + kk = val[MULTI_DMA] >> 8; + err_dma += mode_loop(jj, kk, 'm', &have_mode); } - if((val[WHATS_VALID] & OK_W88) && val[ULTRA_DMA]) { - jj = val[ULTRA_DMA]; kk = val[ULTRA_DMA] >> 8; - err_dma += mode_loop(jj,kk,'u',&have_mode); + if ((val[WHATS_VALID] & OK_W88) && val[ULTRA_DMA]) { + jj = val[ULTRA_DMA]; + kk = val[ULTRA_DMA] >> 8; + err_dma += mode_loop(jj, kk, 'u', &have_mode); } - if(err_dma || !have_mode) printf("(?)"); - printf("\n"); - - if((dev == ATAPI_DEV) && (eqpt != CDROM) && (val[CAPAB_0] & DMA_IL_SUP)) - printf("\t Interleaved DMA support\n"); - - if((val[WHATS_VALID] & OK_W64_70) && - (val[DMA_TIME_MIN] || val[DMA_TIME_NORM])) { - printf("\t Cycle time:"); - if(val[DMA_TIME_MIN]) - printf(" min=%uns",val[DMA_TIME_MIN]); - if(val[DMA_TIME_NORM]) - printf(" recommended=%uns",val[DMA_TIME_NORM]); - printf("\n"); + if (err_dma || !have_mode) printf("(?)"); + bb_putchar('\n'); + + if ((dev == ATAPI_DEV) && (eqpt != CDROM) && (val[CAPAB_0] & DMA_IL_SUP)) + printf("\t\tInterleaved DMA support\n"); + + if ((val[WHATS_VALID] & OK_W64_70) + && (val[DMA_TIME_MIN] || val[DMA_TIME_NORM]) + ) { + printf("\t\tCycle time:"); + if (val[DMA_TIME_MIN]) printf(" min=%uns", val[DMA_TIME_MIN]); + if (val[DMA_TIME_NORM]) printf(" recommended=%uns", val[DMA_TIME_NORM]); + bb_putchar('\n'); } } /* Programmed IO stuff */ printf("\tPIO: "); - /* If a drive supports mode n (e.g. 3), it also supports all modes less + /* If a drive supports mode n (e.g. 3), it also supports all modes less * than n (e.g. 3, 2, 1 and 0). Print all the modes. */ - if((val[WHATS_VALID] & OK_W64_70) && (val[ADV_PIO_MODES] & PIO_SUP)) { + if ((val[WHATS_VALID] & OK_W64_70) && (val[ADV_PIO_MODES] & PIO_SUP)) { jj = ((val[ADV_PIO_MODES] & PIO_SUP) << 3) | 0x0007; - for(ii = 0; ii <= PIO_MODE_MAX ; ii++) { - if(jj & 0x0001) - printf("pio%d ",ii); + for (ii = 0; ii <= PIO_MODE_MAX; ii++) { + if (jj & 0x0001) printf("pio%d ", ii); jj >>=1; } - printf("\n"); - } else if(((min_std < 5) || (eqpt == CDROM)) && (val[PIO_MODE] & MODE) ) { - for(ii = 0; ii <= val[PIO_MODE]>>8; ii++) { - printf("pio%d ",ii); - } - printf("\n"); - } else printf("unknown\n"); - if(val[WHATS_VALID] & OK_W64_70) { - if(val[PIO_NO_FLOW] || val[PIO_FLOW]) { - printf("\t Cycle time:"); - if(val[PIO_NO_FLOW]) - printf(" no flow control=%uns", val[PIO_NO_FLOW]); - if(val[PIO_FLOW]) - printf(" IORDY flow control=%uns", val[PIO_FLOW]); - printf("\n"); + bb_putchar('\n'); + } else if (((min_std < 5) || (eqpt == CDROM)) && (val[PIO_MODE] & MODE)) { + for (ii = 0; ii <= val[PIO_MODE]>>8; ii++) + printf("pio%d ", ii); + bb_putchar('\n'); + } else + puts("unknown"); + + if (val[WHATS_VALID] & OK_W64_70) { + if (val[PIO_NO_FLOW] || val[PIO_FLOW]) { + printf("\t\tCycle time:"); + if (val[PIO_NO_FLOW]) printf(" no flow control=%uns", val[PIO_NO_FLOW]); + if (val[PIO_FLOW]) printf(" IORDY flow control=%uns", val[PIO_FLOW]); + bb_putchar('\n'); } } - if((val[CMDS_SUPP_1] & VALID) == VALID_VAL){ + if ((val[CMDS_SUPP_1] & VALID) == VALID_VAL) { printf("Commands/features:\n\tEnabled\tSupported:\n"); jj = val[CMDS_SUPP_0]; kk = val[CMDS_EN_0]; - for(ii = 0; ii < NUM_CMD_FEAT_STR; ii++) { - if((jj & 0x8000) && (*cmd_feat_str[ii] != '\0')) { - if(kk & 0x8000) printf("\t *"); - else printf("\t"); - printf("\t%s\n",cmd_feat_str[ii]); + for (ii = 0; ii < NUM_CMD_FEAT_STR; ii++) { + const char *feat_str = nth_string(cmd_feat_str, ii); + if ((jj & 0x8000) && (*feat_str != '\0')) { + printf("\t%s\t%s\n", (kk & 0x8000) ? " *" : "", feat_str); } - jj <<=1; kk<<=1; - if(ii%16 == 15) { + jj <<= 1; + kk <<= 1; + if (ii % 16 == 15) { jj = val[CMDS_SUPP_0+1+(ii/16)]; kk = val[CMDS_EN_0+1+(ii/16)]; } - if(ii == 31) { - if((val[CMDS_SUPP_2] & VALID) != VALID_VAL) ii +=16; + if (ii == 31) { + if ((val[CMDS_SUPP_2] & VALID) != VALID_VAL) + ii +=16; } } } - if((val[RM_STAT] & RM_STAT_BITS) == RM_STAT_SUP) - printf("\tRemovable Media Status Notification feature set supported\n"); - - + /* Removable Media Status Notification feature set */ + if ((val[RM_STAT] & RM_STAT_BITS) == RM_STAT_SUP) + printf("\t%s supported\n", nth_string(cmd_feat_str, 27)); + /* security */ - if((eqpt != CDROM) && (like_std > 3) && - (val[SECU_STATUS] || val[ERASE_TIME] || val[ENH_ERASE_TIME])) { - printf("Security: \n"); - if(val[PSWD_CODE] && (val[PSWD_CODE] != NOVAL_1)) - printf("\tMaster password revision code = %u\n",val[PSWD_CODE]); + if ((eqpt != CDROM) && (like_std > 3) + && (val[SECU_STATUS] || val[ERASE_TIME] || val[ENH_ERASE_TIME]) + ) { + printf("Security:\n"); + if (val[PSWD_CODE] && (val[PSWD_CODE] != NOVAL_1)) + printf("\tMaster password revision code = %u\n", val[PSWD_CODE]); jj = val[SECU_STATUS]; - if(jj) { - for(ii = 0; ii < NUM_SECU_STR; ii++) { - if(!(jj & 0x0001)) printf("\tnot\t"); - else printf("\t\t"); - printf("%s\n",secu_str[ii]); + if (jj) { + for (ii = 0; ii < NUM_SECU_STR; ii++) { + printf("\t%s\t%s\n", (!(jj & 0x0001)) ? "not" : "", nth_string(secu_str, ii)); jj >>=1; } - if(val[SECU_STATUS] & SECU_ENABLED) { - printf("\tSecurity level "); - if(val[SECU_STATUS] & SECU_LEVEL) printf("maximum\n"); - else printf("high\n"); + if (val[SECU_STATUS] & SECU_ENABLED) { + printf("\tSecurity level %s\n", (val[SECU_STATUS] & SECU_LEVEL) ? "maximum" : "high"); } } jj = val[ERASE_TIME] & ERASE_BITS; kk = val[ENH_ERASE_TIME] & ERASE_BITS; - if(jj || kk) { - printf("\t"); - if(jj) printf("%umin for SECURITY ERASE UNIT. ", jj==ERASE_BITS ? 508 : jj<<1); - if(kk) printf("%umin for ENHANCED SECURITY ERASE UNIT.", kk==ERASE_BITS ? 508 : kk<<1); - printf("\n"); + if (jj || kk) { + bb_putchar('\t'); + if (jj) printf("%umin for %sSECURITY ERASE UNIT. ", jj==ERASE_BITS ? 508 : jj<<1, ""); + if (kk) printf("%umin for %sSECURITY ERASE UNIT. ", kk==ERASE_BITS ? 508 : kk<<1, "ENHANCED "); + bb_putchar('\n'); } } /* reset result */ - if((val[HWRST_RSLT] & VALID) == VALID_VAL) { - printf("HW reset results:\n"); - if(val[HWRST_RSLT] & CBLID) printf("\tCBLID- above Vih\n"); - else printf("\tCBLID- below Vih\n"); - if(val[HWRST_RSLT] & RST0) { - printf("\tDevice num = 0"); - jj = val[HWRST_RSLT]; - } else { - printf("\tDevice num = 1"); - jj = val[HWRST_RSLT] >> 8; - } - if((jj & DEV_DET) == JUMPER_VAL) - printf(" determined by the jumper"); - else if((jj & DEV_DET) == CSEL_VAL) - printf(" determined by CSEL"); - printf("\n"); + jj = val[HWRST_RSLT]; + if ((jj & VALID) == VALID_VAL) { + oo = (jj & RST0); + if (!oo) + jj >>= 8; + if ((jj & DEV_DET) == JUMPER_VAL) + strng = " determined by the jumper"; + else if ((jj & DEV_DET) == CSEL_VAL) + strng = " determined by CSEL"; + else + strng = ""; + printf("HW reset results:\n\tCBLID- %s Vih\n\tDevice num = %i%s\n", + (val[HWRST_RSLT] & CBLID) ? "above" : "below", !(oo), strng); } /* more stuff from std 5 */ - if((like_std > 4) && (eqpt != CDROM)) { - if(val[CFA_PWR_MODE] & VALID_W160) { - printf("CFA power mode 1:\n\t"); - if(val[CFA_PWR_MODE] & PWR_MODE_OFF) printf("dis"); - else printf("en"); - printf("abled"); - if(val[CFA_PWR_MODE] & PWR_MODE_REQ) - printf(" and required by some commands"); - printf("\n"); - if(val[CFA_PWR_MODE] & MAX_AMPS) - printf("\tMaximum current = %uma\n",val[CFA_PWR_MODE] & MAX_AMPS); + if ((like_std > 4) && (eqpt != CDROM)) { + if (val[CFA_PWR_MODE] & VALID_W160) { + printf("CFA power mode 1:\n\t%s%s\n", (val[CFA_PWR_MODE] & PWR_MODE_OFF) ? "disabled" : "enabled", + (val[CFA_PWR_MODE] & PWR_MODE_REQ) ? " and required by some commands" : ""); + + if (val[CFA_PWR_MODE] & MAX_AMPS) + printf("\tMaximum current = %uma\n", val[CFA_PWR_MODE] & MAX_AMPS); } - if((val[INTEGRITY] & SIG) == SIG_VAL) { - printf("Checksum: "); - if(chksum) printf("in"); - printf("correct\n"); + if ((val[INTEGRITY] & SIG) == SIG_VAL) { + printf("Checksum: %scorrect\n", chksum ? "in" : ""); } } - exit(0); + exit(EXIT_SUCCESS); } #endif -#define VERSION "v5.4" - -#undef DO_FLUSHCACHE /* under construction: force cache flush on -W0 */ -#define TIMING_BUF_MB 2 -#define TIMING_BUF_BYTES (TIMING_BUF_MB * 1024 * 1024) -#define BUFCACHE_FACTOR 2 - -static int verbose = 0, get_identity = 0, get_geom = 0, noisy = 1, quiet = 0; -static int flagcount = 0, do_flush = 0, is_scsi_hd = 0, is_xt_hd = 0; -static int do_ctimings, do_timings = 0; - -static unsigned long set_readahead= 0, get_readahead= 0, readahead= 0; -static unsigned long set_readonly = 0, get_readonly = 0, readonly = 0; -static unsigned long set_unmask = 0, get_unmask = 0, unmask = 0; -static unsigned long set_mult = 0, get_mult = 0, mult = 0; -static unsigned long set_dma = 0, get_dma = 0, dma = 0; -static unsigned long set_dma_q = 0, get_dma_q = 0, dma_q = 0; -static unsigned long set_nowerr = 0, get_nowerr = 0, nowerr = 0; -static unsigned long set_keep = 0, get_keep = 0, keep = 0; -static unsigned long set_io32bit = 0, get_io32bit = 0, io32bit = 0; -static unsigned long set_piomode = 0, noisy_piomode= 0; -static int piomode = 0; -#ifdef HDIO_DRIVE_CMD -static unsigned long set_dkeep = 0, get_dkeep = 0, dkeep = 0; -static unsigned long set_standby = 0, get_standby = 0, standby_requested= 0; -static unsigned long set_xfermode = 0, get_xfermode = 0; -static int xfermode_requested= 0; -static unsigned long set_lookahead= 0, get_lookahead= 0, lookahead= 0; -static unsigned long set_prefetch = 0, get_prefetch = 0, prefetch = 0; -static unsigned long set_defects = 0, get_defects = 0, defects = 0; -static unsigned long set_wcache = 0, get_wcache = 0, wcache = 0; -static unsigned long set_doorlock = 0, get_doorlock = 0, doorlock = 0; -static unsigned long set_seagate = 0, get_seagate = 0; -static unsigned long set_standbynow = 0, get_standbynow = 0; -static unsigned long set_sleepnow = 0, get_sleepnow = 0; -static unsigned long get_powermode = 0; -static unsigned long set_apmmode = 0, get_apmmode= 0, apmmode = 0; -#endif -#ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY -static int get_IDentity = 0; -#endif -#ifdef CONFIG_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF -static int unregister_hwif = 0; -static int hwif = 0; -#endif -#ifdef CONFIG_FEATURE_HDPARM_HDIO_SCAN_HWIF -static int scan_hwif = 0; -static int hwif_data = 0; -static int hwif_ctrl = 0; -static int hwif_irq = 0; -#endif -#ifdef CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF -static int set_busstate = 0, get_busstate = 0, busstate = 0; -#endif -static int reread_partn = 0; - -#ifdef CONFIG_FEATURE_HDPARM_HDIO_DRIVE_RESET -static int perform_reset = 0; -#endif /* CONFIG_FEATURE_HDPARM_HDIO_DRIVE_RESET */ -#ifdef CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF -static int perform_tristate = 0, tristate = 0; -#endif /* CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF */ - // Historically, if there was no HDIO_OBSOLETE_IDENTITY, then // then the HDIO_GET_IDENTITY only returned 142 bytes. // Otherwise, HDIO_OBSOLETE_IDENTITY returns 142 bytes, @@ -1095,881 +1160,529 @@ static int perform_tristate = 0, tristate = 0; // On a really old system, it will not, and we will be confused. // Too bad, really. -#ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY -static const char *cfg_str[] = -{ "", " HardSect", " SoftSect", " NotMFM", - " HdSw>15uSec", " SpinMotCtl", " Fixed", " Removeable", - " DTR<=5Mbs", " DTR>5Mbs", " DTR>10Mbs", " RotSpdTol>.5%", - " dStbOff", " TrkOff", " FmtGapReq", " nonMagnetic" -}; - -static const char *BuffType[] = {"unknown", "1Sect", "DualPort", "DualPortCache"}; +#if ENABLE_FEATURE_HDPARM_GET_IDENTITY +static const char cfg_str[] ALIGN1 = + """\0" "HardSect""\0" "SoftSect""\0" "NotMFM""\0" + "HdSw>15uSec""\0" "SpinMotCtl""\0" "Fixed""\0" "Removeable""\0" + "DTR<=5Mbs""\0" "DTR>5Mbs""\0" "DTR>10Mbs""\0" "RotSpdTol>.5%""\0" + "dStbOff""\0" "TrkOff""\0" "FmtGapReq""\0" "nonMagnetic" +; -#define YN(b) (((b)==0)?"no":"yes") +static const char BuffType[] ALIGN1 = + "unknown""\0" "1Sect""\0" "DualPort""\0" "DualPortCache" +; -static void dmpstr (const char *prefix, unsigned int i, const char *s[], unsigned int maxi) -{ - if (i > maxi) - printf("%s%u", prefix, i); - else - printf("%s%s", prefix, s[i]); -} - -static void dump_identity (const struct hd_driveid *id) +static void dump_identity(const struct hd_driveid *id) { int i; - char pmodes[64] = {0,}, dmodes[128]={0,}, umodes[128]={0,}; - const unsigned short int *id_regs= (const void*) id; - unsigned long capacity; - - printf("\n Model=%.40s, FwRev=%.8s, SerialNo=%.20s", - id->model, id->fw_rev, id->serial_no); - printf("\n Config={"); - for (i=0; i<=15; i++) { + const unsigned short *id_regs = (const void*) id; + + printf("\n Model=%.40s, FwRev=%.8s, SerialNo=%.20s\n Config={", + id->model, id->fw_rev, id->serial_no); + for (i = 0; i <= 15; i++) { if (id->config & (1<<i)) - printf("%s", cfg_str[i]); - } - printf(" }\n"); - printf(" RawCHS=%u/%u/%u, TrkSize=%u, SectSize=%u, ECCbytes=%u\n", - id->cyls, id->heads, id->sectors, - id->track_bytes, id->sector_bytes, id->ecc_bytes); - dmpstr(" BuffType=",id->buf_type,BuffType,3); - printf(", BuffSize=%ukB, MaxMultSect=%u", id->buf_size/2, id->max_multsect); + printf(" %s", nth_string(cfg_str, i)); + } + printf(" }\n RawCHS=%u/%u/%u, TrkSize=%u, SectSize=%u, ECCbytes=%u\n" + " BuffType=(%u) %s, BuffSize=%ukB, MaxMultSect=%u", + id->cyls, id->heads, id->sectors, id->track_bytes, + id->sector_bytes, id->ecc_bytes, + id->buf_type, nth_string(BuffType, (id->buf_type > 3) ? 0 : id->buf_type), + id->buf_size/2, id->max_multsect); if (id->max_multsect) { printf(", MultSect="); - if (!(id->multsect_valid&1)) + if (!(id->multsect_valid & 1)) printf("?%u?", id->multsect); else if (id->multsect) printf("%u", id->multsect); else printf("off"); } - putchar('\n'); - if (id->tPIO <= 5) { - strcat(pmodes, "pio0 "); - if (id->tPIO >= 1) strcat(pmodes, "pio1 "); - if (id->tPIO >= 2) strcat(pmodes, "pio2 "); - } - if (!(id->field_valid&1)) + bb_putchar('\n'); + + if (!(id->field_valid & 1)) printf(" (maybe):"); -#if __BYTE_ORDER == __BIG_ENDIAN - capacity = (id->cur_capacity0 << 16) | id->cur_capacity1; -#else - capacity = (id->cur_capacity1 << 16) | id->cur_capacity0; -#endif - printf(" CurCHS=%u/%u/%u, CurSects=%lu", id->cur_cyls, id->cur_heads, id->cur_sectors, capacity); - printf(", LBA=%s", YN(id->capability&2)); - if (id->capability&2) - printf(", LBAsects=%u", id->lba_capacity); - if (id->capability&1) { + printf(" CurCHS=%u/%u/%u, CurSects=%lu, LBA=%s", id->cur_cyls, id->cur_heads, + id->cur_sectors, + (BB_BIG_ENDIAN) ? + (unsigned long)(id->cur_capacity0 << 16) | id->cur_capacity1 : + (unsigned long)(id->cur_capacity1 << 16) | id->cur_capacity0, + ((id->capability&2) == 0) ? "no" : "yes"); + + if (id->capability & 2) + printf(", LBAsects=%u", id->lba_capacity); + + printf("\n IORDY=%s", (id->capability & 8) ? (id->capability & 4) ? "on/off" : "yes" : "no"); + + if (((id->capability & 8) || (id->field_valid & 2)) && (id->field_valid & 2)) + printf(", tPIO={min:%u,w/IORDY:%u}", id->eide_pio, id->eide_pio_iordy); + + if ((id->capability & 1) && (id->field_valid & 2)) + printf(", tDMA={min:%u,rec:%u}", id->eide_dma_min, id->eide_dma_time); + + printf("\n PIO modes: "); + if (id->tPIO <= 5) { + printf("pio0 "); + if (id->tPIO >= 1) printf("pio1 "); + if (id->tPIO >= 2) printf("pio2 "); + } + if (id->field_valid & 2) { + static const masks_labels_t pio_modes = { + .masks = { 1, 2, ~3 }, + .labels = "pio3 \0""pio4 \0""pio? \0", + }; + print_flags(&pio_modes, id->eide_pio_modes); + } + if (id->capability & 1) { if (id->dma_1word | id->dma_mword) { - if (id->dma_1word & 0x100) strcat(dmodes,"*"); - if (id->dma_1word & 1) strcat(dmodes,"sdma0 "); - if (id->dma_1word & 0x200) strcat(dmodes,"*"); - if (id->dma_1word & 2) strcat(dmodes,"sdma1 "); - if (id->dma_1word & 0x400) strcat(dmodes,"*"); - if (id->dma_1word & 4) strcat(dmodes,"sdma2 "); - if (id->dma_1word & 0xf800) strcat(dmodes,"*"); - if (id->dma_1word & 0xf8) strcat(dmodes,"sdma? "); - if (id->dma_mword & 0x100) strcat(dmodes,"*"); - if (id->dma_mword & 1) strcat(dmodes,"mdma0 "); - if (id->dma_mword & 0x200) strcat(dmodes,"*"); - if (id->dma_mword & 2) strcat(dmodes,"mdma1 "); - if (id->dma_mword & 0x400) strcat(dmodes,"*"); - if (id->dma_mword & 4) strcat(dmodes,"mdma2 "); - if (id->dma_mword & 0xf800) strcat(dmodes,"*"); - if (id->dma_mword & 0xf8) strcat(dmodes,"mdma? "); - } - } - printf("\n IORDY="); - if (id->capability&8) - printf((id->capability&4) ? "on/off" : "yes"); - else - printf("no"); - if ((id->capability&8) || (id->field_valid&2)) { - if (id->field_valid&2) { - printf(", tPIO={min:%u,w/IORDY:%u}", id->eide_pio, id->eide_pio_iordy); - if (id->eide_pio_modes & 1) strcat(pmodes, "pio3 "); - if (id->eide_pio_modes & 2) strcat(pmodes, "pio4 "); - if (id->eide_pio_modes &~3) strcat(pmodes, "pio? "); - } - if (id->field_valid&4) { - if (id->dma_ultra & 0x100) strcat(umodes,"*"); - if (id->dma_ultra & 0x001) strcat(umodes,"udma0 "); - if (id->dma_ultra & 0x200) strcat(umodes,"*"); - if (id->dma_ultra & 0x002) strcat(umodes,"udma1 "); - if (id->dma_ultra & 0x400) strcat(umodes,"*"); - if (id->dma_ultra & 0x004) strcat(umodes,"udma2 "); + static const int dma_wmode_masks[] = { 0x100, 1, 0x200, 2, 0x400, 4, 0xf800, 0xf8 }; + printf("\n DMA modes: "); + print_flags_separated(dma_wmode_masks, + "*\0""sdma0 \0""*\0""sdma1 \0""*\0""sdma2 \0""*\0""sdma? \0", + id->dma_1word, NULL); + print_flags_separated(dma_wmode_masks, + "*\0""mdma0\0""*\0""mdma1\0""*\0""mdma2\0""*\0""mdma?\0", + id->dma_mword, NULL); + } + } + if (((id->capability & 8) || (id->field_valid & 2)) && id->field_valid & 4) { + static const masks_labels_t ultra_modes1 = { + .masks = { 0x100, 0x001, 0x200, 0x002, 0x400, 0x004 }, + .labels = "*\0""udma0 \0""*\0""udma1 \0""*\0""udma2 \0", + }; + + printf("\n UDMA modes: "); + print_flags(&ultra_modes1, id->dma_ultra); #ifdef __NEW_HD_DRIVE_ID - if (id->hw_config & 0x2000) { + if (id->hw_config & 0x2000) { #else /* !__NEW_HD_DRIVE_ID */ - if (id->word93 & 0x2000) { + if (id->word93 & 0x2000) { #endif /* __NEW_HD_DRIVE_ID */ - if (id->dma_ultra & 0x0800) strcat(umodes,"*"); - if (id->dma_ultra & 0x0008) strcat(umodes,"udma3 "); - if (id->dma_ultra & 0x1000) strcat(umodes,"*"); - if (id->dma_ultra & 0x0010) strcat(umodes,"udma4 "); - if (id->dma_ultra & 0x2000) strcat(umodes,"*"); - if (id->dma_ultra & 0x0020) strcat(umodes,"udma5 "); - if (id->dma_ultra & 0x4000) strcat(umodes,"*"); - if (id->dma_ultra & 0x0040) strcat(umodes,"udma6 "); - if (id->dma_ultra & 0x8000) strcat(umodes,"*"); - if (id->dma_ultra & 0x0080) strcat(umodes,"udma7 "); - } - } + static const masks_labels_t ultra_modes2 = { + .masks = { 0x0800, 0x0008, 0x1000, 0x0010, + 0x2000, 0x0020, 0x4000, 0x0040, + 0x8000, 0x0080 }, + .labels = "*\0""udma3 \0""*\0""udma4 \0" + "*\0""udma5 \0""*\0""udma6 \0" + "*\0""udma7 \0" + }; + print_flags(&ultra_modes2, id->dma_ultra); + } + } + printf("\n AdvancedPM=%s", (!(id_regs[83] & 8)) ? "no" : "yes"); + if (id_regs[83] & 8) { + if (!(id_regs[86] & 8)) + printf(": disabled (255)"); + else if ((id_regs[91] & 0xFF00) != 0x4000) + printf(": unknown setting"); + else + printf(": mode=0x%02X (%u)", id_regs[91] & 0xFF, id_regs[91] & 0xFF); } - if ((id->capability&1) && (id->field_valid&2)) - printf(", tDMA={min:%u,rec:%u}", id->eide_dma_min, id->eide_dma_time); - printf("\n PIO modes: %s", pmodes); - if (*dmodes) - printf("\n DMA modes: %s", dmodes); - if (*umodes) - printf("\n UDMA modes: %s", umodes); - - printf("\n AdvancedPM=%s",YN(id_regs[83]&8)); - if (id_regs[83] & 8) { - if (!(id_regs[86]&8)) - printf(": disabled (255)"); - else if ((id_regs[91]&0xFF00)!=0x4000) - printf(": unknown setting"); - else - printf(": mode=0x%02X (%u)",id_regs[91]&0xFF,id_regs[91]&0xFF); - } - if (id_regs[82]&0x20) - printf(" WriteCache=%s",(id_regs[85]&0x20) ? "enabled" : "disabled"); + if (id_regs[82] & 0x20) + printf(" WriteCache=%s", (id_regs[85] & 0x20) ? "enabled" : "disabled"); #ifdef __NEW_HD_DRIVE_ID - if ((id->minor_rev_num && id->minor_rev_num <= 31) || (id->major_rev_num && id->minor_rev_num <= 31)) { - printf("\n Drive conforms to: "); - if (id->minor_rev_num <= 31) - printf("%s: ", minor_str[id->minor_rev_num]); - else - printf("unknown: "); - if (id->major_rev_num < 31) { - for (i=0; i <= 15; i++) { + if ((id->minor_rev_num && id->minor_rev_num <= 31) + || (id->major_rev_num && id->minor_rev_num <= 31) + ) { + printf("\n Drive conforms to: %s: ", (id->minor_rev_num <= 31) ? nth_string(minor_str, id->minor_rev_num) : "unknown"); + if (id->major_rev_num != 0x0000 && /* NOVAL_0 */ + id->major_rev_num != 0xFFFF) { /* NOVAL_1 */ + for (i = 0; i <= 15; i++) { if (id->major_rev_num & (1<<i)) - printf(" %u", i); + printf(" ATA/ATAPI-%u", i); } } } #endif /* __NEW_HD_DRIVE_ID */ - printf("\n"); - printf("\n * signifies the current active mode\n"); - printf("\n"); + printf("\n\n * current active mode\n\n"); } #endif -static void flush_buffer_cache (int fd) +static void flush_buffer_cache(/*int fd*/ void) { - fsync (fd); /* flush buffers */ - if (ioctl(fd, BLKFLSBUF, NULL)) /* do it again, big time */ - bb_perror_msg("BLKFLSBUF failed"); + fsync(fd); /* flush buffers */ + ioctl_or_warn(fd, BLKFLSBUF, NULL); /* do it again, big time */ #ifdef HDIO_DRIVE_CMD - if (is_scsi_hd || is_xt_hd) { - sleep(1); - } else { - if (ioctl(fd, HDIO_DRIVE_CMD, NULL) && errno != EINVAL) /* await completion */ - bb_perror_msg("HDIO_DRIVE_CMD(null) (wait for flush complete) failed"); + sleep(1); + if (ioctl(fd, HDIO_DRIVE_CMD, NULL) && errno != EINVAL) { /* await completion */ + if (ENABLE_IOCTL_HEX2STR_ERROR) /* To be coherent with ioctl_or_warn */ + bb_perror_msg("HDIO_DRIVE_CMD"); + else + bb_perror_msg("ioctl %#x failed", HDIO_DRIVE_CMD); } #endif } -static int seek_to_zero (int fd) +static void seek_to_zero(/*int fd*/ void) { - if (lseek(fd, (off_t) 0, SEEK_SET)) { - bb_perror_msg("lseek() failed"); - return 1; - } - return 0; + xlseek(fd, (off_t) 0, SEEK_SET); } -static int read_big_block (int fd, char *buf) +static void read_big_block(/*int fd,*/ char *buf) { - int i, rc; - if ((rc = read(fd, buf, TIMING_BUF_BYTES)) != TIMING_BUF_BYTES) { - if (rc) { - if (rc == -1) - bb_perror_msg("read() failed"); - else - bb_error_msg("read(%u) returned %u bytes", TIMING_BUF_BYTES, rc); - } else { - fputs ("read() hit EOF - device too small\n", stderr); - } - return 1; - } + int i; + + xread(fd, buf, TIMING_BUF_BYTES); /* access all sectors of buf to ensure the read fully completed */ for (i = 0; i < TIMING_BUF_BYTES; i += 512) buf[i] &= 1; - return 0; } -static void time_cache (int fd) +static unsigned dev_size_mb(/*int fd*/ void) { - char *buf; - struct itimerval e1, e2; - int shmid; - double elapsed, elapsed2; - unsigned int iterations, total_MB; - - if ((shmid = shmget(IPC_PRIVATE, TIMING_BUF_BYTES, 0600)) == -1) { - bb_perror_msg ("could not allocate sharedmem buf"); - return; - } - if (shmctl(shmid, SHM_LOCK, NULL) == -1) { - bb_perror_msg ("could not lock sharedmem buf"); - (void) shmctl(shmid, IPC_RMID, NULL); - return; - } - if ((buf = shmat(shmid, (char *) 0, 0)) == (char *) -1) { - bb_perror_msg ("could not attach sharedmem buf"); - (void) shmctl(shmid, IPC_RMID, NULL); - return; - } - if (shmctl(shmid, IPC_RMID, NULL) == -1) - bb_perror_msg ("shmctl(,IPC_RMID,) failed"); - - /* Clear out the device request queues & give them time to complete */ - sync(); - sleep(3); - - /* - * getitimer() is used rather than gettimeofday() because - * it is much more consistent (on my machine, at least). - */ - setitimer(ITIMER_REAL, &(struct itimerval){{1000,0},{1000,0}}, NULL); - if (seek_to_zero (fd)) return; - if (read_big_block (fd, buf)) return; - printf(" Timing buffer-cache reads: "); - fflush(stdout); - - /* Clear out the device request queues & give them time to complete */ - sync(); - sleep(1); - - /* Now do the timing */ - iterations = 0; - getitimer(ITIMER_REAL, &e1); - do { - ++iterations; - if (seek_to_zero (fd) || read_big_block (fd, buf)) - goto quit; - getitimer(ITIMER_REAL, &e2); - elapsed = (e1.it_value.tv_sec - e2.it_value.tv_sec) - + ((e1.it_value.tv_usec - e2.it_value.tv_usec) / 1000000.0); - } while (elapsed < 2.0); - total_MB = iterations * TIMING_BUF_MB; - - elapsed = (e1.it_value.tv_sec - e2.it_value.tv_sec) - + ((e1.it_value.tv_usec - e2.it_value.tv_usec) / 1000000.0); - - /* Now remove the lseek() and getitimer() overheads from the elapsed time */ - getitimer(ITIMER_REAL, &e1); - do { - if (seek_to_zero (fd)) - goto quit; - getitimer(ITIMER_REAL, &e2); - elapsed2 = (e1.it_value.tv_sec - e2.it_value.tv_sec) - + ((e1.it_value.tv_usec - e2.it_value.tv_usec) / 1000000.0); - } while (--iterations); - - elapsed -= elapsed2; - - if ((BUFCACHE_FACTOR * total_MB) >= elapsed) /* more than 1MB/s */ - printf("%3u MB in %5.2f seconds = %6.2f MB/sec\n", - (BUFCACHE_FACTOR * total_MB), elapsed, - (BUFCACHE_FACTOR * total_MB) / elapsed); - else - printf("%3u MB in %5.2f seconds = %6.2f kB/sec\n", - (BUFCACHE_FACTOR * total_MB), elapsed, - (BUFCACHE_FACTOR * total_MB) / elapsed * 1024); + union { + unsigned long long blksize64; + unsigned blksize32; + } u; - flush_buffer_cache(fd); - sleep(1); -quit: - if (-1 == shmdt(buf)) - bb_perror_msg ("could not detach sharedmem buf"); + if (0 == ioctl(fd, BLKGETSIZE64, &u.blksize64)) { // bytes + u.blksize64 /= (1024 * 1024); + } else { + xioctl(fd, BLKGETSIZE, &u.blksize32); // sectors + u.blksize64 = u.blksize32 / (2 * 1024); + } + if (u.blksize64 > UINT_MAX) + return UINT_MAX; + return u.blksize64; } -static void time_device (int fd) +static void print_timing(unsigned m, unsigned elapsed_us) { - char *buf; - double elapsed; - struct itimerval e1, e2; - int shmid; - unsigned int max_iterations = 1024, total_MB, iterations; - static long parm; - - // - // get device size - // - if (do_ctimings || do_timings) { - if (ioctl(fd, BLKGETSIZE, &parm)) - bb_perror_msg(" BLKGETSIZE failed"); - else - max_iterations = parm / (2 * 1024) / TIMING_BUF_MB; - } - - if ((shmid = shmget(IPC_PRIVATE, TIMING_BUF_BYTES, 0600)) == -1) { - bb_perror_msg ("could not allocate sharedmem buf"); - return; - } - if (shmctl(shmid, SHM_LOCK, NULL) == -1) { - bb_perror_msg ("could not lock sharedmem buf"); - (void) shmctl(shmid, IPC_RMID, NULL); - return; - } - if ((buf = shmat(shmid, (char *) 0, 0)) == (char *) -1) { - bb_perror_msg ("could not attach sharedmem buf"); - (void) shmctl(shmid, IPC_RMID, NULL); - return; - } - if (shmctl(shmid, IPC_RMID, NULL) == -1) - bb_perror_msg ("shmctl(,IPC_RMID,) failed"); + unsigned sec = elapsed_us / 1000000; + unsigned hs = (elapsed_us % 1000000) / 10000; + + printf("%5u MB in %u.%02u seconds = %u kB/s\n", + m, sec, hs, + /* "| 1" prevents div-by-0 */ + (unsigned) ((unsigned long long)m * (1024 * 1000000) / (elapsed_us | 1)) + // ~= (m * 1024) / (elapsed_us / 1000000) + // = kb / elapsed_sec + ); +} - /* Clear out the device request queues & give them time to complete */ +static void do_time(int cache /*,int fd*/) +/* cache=1: time cache: repeatedly read N MB at offset 0 + * cache=0: time device: linear read, starting at offset 0 + */ +{ + unsigned max_iterations, iterations; + unsigned start; /* doesn't need to be long long */ + unsigned elapsed, elapsed2; + unsigned total_MB; + char *buf = xmalloc(TIMING_BUF_BYTES); + + if (mlock(buf, TIMING_BUF_BYTES)) + bb_perror_msg_and_die("mlock"); + + /* Clear out the device request queues & give them time to complete. + * NB: *small* delay. User is expected to have a clue and to not run + * heavy io in parallel with measurements. */ sync(); - sleep(3); - - printf(" Timing buffered disk reads: "); + sleep(1); + if (cache) { /* Time cache */ + seek_to_zero(); + read_big_block(buf); + printf("Timing buffer-cache reads: "); + } else { /* Time device */ + printf("Timing buffered disk reads:"); + } fflush(stdout); - /* - * getitimer() is used rather than gettimeofday() because - * it is much more consistent (on my machine, at least). - */ - setitimer(ITIMER_REAL, &(struct itimerval){{1000,0},{1000,0}}, NULL); - - /* Now do the timings for real */ + /* Now do the timing */ iterations = 0; - getitimer(ITIMER_REAL, &e1); + /* Max time to run (small for cache, avoids getting + * huge total_MB which can overlow unsigned type) */ + elapsed2 = 510000; /* cache */ + max_iterations = UINT_MAX; + if (!cache) { + elapsed2 = 3000000; /* not cache */ + /* Don't want to read past the end! */ + max_iterations = dev_size_mb() / TIMING_BUF_MB; + } + start = monotonic_us(); do { + if (cache) + seek_to_zero(); + read_big_block(buf); + elapsed = (unsigned)monotonic_us() - start; ++iterations; - if (read_big_block (fd, buf)) - goto quit; - getitimer(ITIMER_REAL, &e2); - elapsed = (e1.it_value.tv_sec - e2.it_value.tv_sec) - + ((e1.it_value.tv_usec - e2.it_value.tv_usec) / 1000000.0); - } while (elapsed < 3.0 && iterations < max_iterations); - + } while (elapsed < elapsed2 && iterations < max_iterations); total_MB = iterations * TIMING_BUF_MB; - if ((total_MB / elapsed) > 1.0) /* more than 1MB/s */ - printf("%3u MB in %5.2f seconds = %6.2f MB/sec\n", - total_MB, elapsed, total_MB / elapsed); - else - printf("%3u MB in %5.2f seconds = %6.2f kB/sec\n", - total_MB, elapsed, total_MB / elapsed * 1024); -quit: - if (-1 == shmdt(buf)) - bb_perror_msg ("could not detach sharedmem buf"); + //printf(" elapsed:%u iterations:%u ", elapsed, iterations); + if (cache) { + /* Cache: remove lseek() and monotonic_us() overheads + * from elapsed */ + start = monotonic_us(); + do { + seek_to_zero(); + elapsed2 = (unsigned)monotonic_us() - start; + } while (--iterations); + //printf(" elapsed2:%u ", elapsed2); + elapsed -= elapsed2; + total_MB *= 2; // BUFCACHE_FACTOR (why?) + flush_buffer_cache(); + } + print_timing(total_MB, elapsed); + munlock(buf, TIMING_BUF_BYTES); + free(buf); } -static void no_scsi (void) +#if ENABLE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF +static void bus_state_value(unsigned value) { - if (is_scsi_hd) { - bb_error_msg_and_die(" operation not supported on SCSI disks\n"); - } -} - -static void no_xt (void) -{ - if (is_xt_hd) { - bb_error_msg_and_die (" operation not supported on XT disks\n"); - } -} - -static void on_off (unsigned int value) -{ - printf(value ? " (on)\n" : " (off)\n"); -} - -#ifdef CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF -static void bus_state_value (unsigned int value) -{ - const char *string; - - switch (value) { - case BUSSTATE_ON: - string = " (on)\n"; - break; - case BUSSTATE_OFF: - string = " (off)\n"; - break; - case BUSSTATE_TRISTATE: - string = " (tristate)\n"; - break; - default: - string = " (unknown: %d)\n"; - break; - } - printf(string, value); + if (value == BUSSTATE_ON) + on_off(1); + else if (value == BUSSTATE_OFF) + on_off(0); + else if (value == BUSSTATE_TRISTATE) + printf(" (tristate)\n"); + else + printf(" (unknown: %d)\n", value); } #endif #ifdef HDIO_DRIVE_CMD -static void interpret_standby (unsigned int standby) +static void interpret_standby(uint8_t standby) { printf(" ("); - switch(standby) { - case 0: printf("off"); - break; - case 252: printf("21 minutes"); - break; - case 253: printf("vendor-specific"); - break; - case 254: printf("?reserved"); - break; - case 255: printf("21 minutes + 15 seconds"); - break; - default: - if (standby <= 240) { - unsigned int secs = standby * 5; - unsigned int mins = secs / 60; - secs %= 60; - if (mins) printf("%u minutes", mins); - if (mins && secs) printf(" + "); - if (secs) printf("%u seconds", secs); - } else if (standby <= 251) { - unsigned int mins = (standby - 240) * 30; - unsigned int hrs = mins / 60; - mins %= 60; - if (hrs) printf("%u hours", hrs); - if (hrs && mins) printf(" + "); - if (mins) printf("%u minutes", mins); - } else - printf("illegal value"); - break; - } + if (standby == 0) { + printf("off"); + } else if (standby <= 240 || standby == 252 || standby == 255) { + /* standby is in 5 sec units */ + printf("%u minutes %u seconds", standby / 12, (standby*5) % 60); + } else if (standby <= 251) { + unsigned t = (standby - 240); /* t is in 30 min units */; + printf("%u.%c hours", t / 2, (t & 1) ? '0' : '5'); + } + if (standby == 253) + printf("vendor-specific"); + if (standby == 254) + printf("reserved"); printf(")\n"); } -struct xfermode_entry { - int val; - const char *name; +static const uint8_t xfermode_val[] ALIGN1 = { + 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, + 32, 33, 34, 35, 36, 37, 38, 39, + 64, 65, 66, 67, 68, 69, 70, 71 }; - -static const struct xfermode_entry xfermode_table[] = { - { 8, "pio0" }, - { 9, "pio1" }, - { 10, "pio2" }, - { 11, "pio3" }, - { 12, "pio4" }, - { 13, "pio5" }, - { 14, "pio6" }, - { 15, "pio7" }, - { 16, "sdma0" }, - { 17, "sdma1" }, - { 18, "sdma2" }, - { 19, "sdma3" }, - { 20, "sdma4" }, - { 21, "sdma5" }, - { 22, "sdma6" }, - { 23, "sdma7" }, - { 32, "mdma0" }, - { 33, "mdma1" }, - { 34, "mdma2" }, - { 35, "mdma3" }, - { 36, "mdma4" }, - { 37, "mdma5" }, - { 38, "mdma6" }, - { 39, "mdma7" }, - { 64, "udma0" }, - { 65, "udma1" }, - { 66, "udma2" }, - { 67, "udma3" }, - { 68, "udma4" }, - { 69, "udma5" }, - { 70, "udma6" }, - { 71, "udma7" }, - { 0, NULL } +/* NB: we save size by _not_ storing terninating NUL! */ +static const char xfermode_name[][5] ALIGN1 = { + "pio0", "pio1", "pio2", "pio3", "pio4", "pio5", "pio6", "pio7", + "sdma0","sdma1","sdma2","sdma3","sdma4","sdma5","sdma6","sdma7", + "mdma0","mdma1","mdma2","mdma3","mdma4","mdma5","mdma6","mdma7", + "udma0","udma1","udma2","udma3","udma4","udma5","udma6","udma7" }; -static int translate_xfermode(char * name) +static int translate_xfermode(const char *name) { - const struct xfermode_entry *tmp; - char *endptr; - int val = -1; - - - for (tmp = xfermode_table; tmp->name != NULL; ++tmp) { - if (!strcmp(name, tmp->name)) - return tmp->val; - } - - val = strtol(name, &endptr, 10); - if (*endptr == '\0') - return val; - - return -1; + int val; + unsigned i; + + for (i = 0; i < ARRAY_SIZE(xfermode_val); i++) { + if (!strncmp(name, xfermode_name[i], 5)) + if (strlen(name) <= 5) + return xfermode_val[i]; + } + /* Negative numbers are invalid and are caught later */ + val = bb_strtoi(name, NULL, 10); + if (!errno) + return val; + return -1; } -static void interpret_xfermode (unsigned int xfermode) +static void interpret_xfermode(unsigned xfermode) { printf(" ("); - switch(xfermode) { - case 0: printf("default PIO mode"); - break; - case 1: printf("default PIO mode, disable IORDY"); - break; - case 8: - case 9: - case 10: - case 11: - case 12: - case 13: - case 14: - case 15: printf("PIO flow control mode%u", xfermode-8); - break; - case 16: - case 17: - case 18: - case 19: - case 20: - case 21: - case 22: - case 23: printf("singleword DMA mode%u", xfermode-16); - break; - case 32: - case 33: - case 34: - case 35: - case 36: - case 37: - case 38: - case 39: printf("multiword DMA mode%u", xfermode-32); - break; - case 64: - case 65: - case 66: - case 67: - case 68: - case 69: - case 70: - case 71: printf("UltraDMA mode%u", xfermode-64); - break; - default: - printf("unknown, probably not valid"); - break; - } + if (xfermode == 0) + printf("default PIO mode"); + else if (xfermode == 1) + printf("default PIO mode, disable IORDY"); + else if (xfermode >= 8 && xfermode <= 15) + printf("PIO flow control mode%u", xfermode - 8); + else if (xfermode >= 16 && xfermode <= 23) + printf("singleword DMA mode%u", xfermode - 16); + else if (xfermode >= 32 && xfermode <= 39) + printf("multiword DMA mode%u", xfermode - 32); + else if (xfermode >= 64 && xfermode <= 71) + printf("UltraDMA mode%u", xfermode - 64); + else + printf("unknown"); printf(")\n"); } #endif /* HDIO_DRIVE_CMD */ -#ifndef VXVM_MAJOR -#define VXVM_MAJOR 199 -#endif - -#ifndef CCISS_MAJOR -#define CCISS_MAJOR 104 -#endif +static void print_flag(int flag, const char *s, unsigned long value) +{ + if (flag) + printf(" setting %s to %ld\n", s, value); +} -static void process_dev (char *devname) +static void process_dev(char *devname) { - int fd; - static long parm, multcount; - struct stat stat_buf; + /*int fd;*/ + long parm, multcount; #ifndef HDIO_DRIVE_CMD int force_operation = 0; #endif - if (stat(devname,&stat_buf)) - bb_perror_msg_and_die(devname); - - switch(major(stat_buf.st_rdev)) { -#ifdef SCSI_DISK0_MAJOR - case (SCSI_DISK0_MAJOR): - case (SCSI_DISK1_MAJOR): - case (SCSI_DISK2_MAJOR): - case (SCSI_DISK3_MAJOR): - case (SCSI_DISK4_MAJOR): - case (SCSI_DISK5_MAJOR): - case (SCSI_DISK6_MAJOR): - case (SCSI_DISK7_MAJOR): -#else - case (SCSI_DISK_MAJOR): -#endif -#ifdef MD_MAJOR - case (MD_MAJOR): -#endif - case (VXVM_MAJOR): -#ifdef LVM_BLK_MAJOR - case (LVM_BLK_MAJOR): -#endif - case (CCISS_MAJOR): - is_scsi_hd = 1; - break; -#ifdef XT_DISK_MAJOR - case (XT_DISK_MAJOR): - is_xt_hd = 1; - break; -#endif - case IDE0_MAJOR: - case IDE1_MAJOR: -#ifdef IDE2_MAJOR - case IDE2_MAJOR: -#endif -#ifdef IDE3_MAJOR - case IDE3_MAJOR: -#endif -#ifdef IDE4_MAJOR - case IDE4_MAJOR: -#endif -#ifdef IDE5_MAJOR - case IDE5_MAJOR: -#endif -#ifdef IDE6_MAJOR - case IDE6_MAJOR: -#endif -#ifdef IDE7_MAJOR - case IDE7_MAJOR: -#endif -#ifdef IDE8_MAJOR - case IDE8_MAJOR: -#endif -#ifdef IDE9_MAJOR - case IDE9_MAJOR: -#endif - break; /* do nothing */ - default: - bb_error_msg_and_die("%s not supported by hdparm",devname); - } + /* Please restore args[n] to these values after each ioctl + except for args[2] */ + unsigned char args[4] = { WIN_SETFEATURES, 0, 0, 0 }; + const char *fmt = " %s\t= %2ld"; - fd = open (devname, O_RDONLY|O_NONBLOCK); - if (fd < 0) - bb_perror_msg_and_die(devname); - if (!quiet) - printf("\n%s:\n", devname); + /*fd = xopen(devname, O_RDONLY | O_NONBLOCK);*/ + xmove_fd(xopen(devname, O_RDONLY | O_NONBLOCK), fd); + printf("\n%s:\n", devname); if (set_readahead) { - if (get_readahead) - printf(" setting fs readahead to %ld\n", readahead); - if (ioctl(fd, BLKRASET, readahead)) - bb_perror_msg(" BLKRASET failed"); + print_flag(get_readahead, "fs readahead", Xreadahead); + ioctl_or_warn(fd, BLKRASET, (int *)Xreadahead); } -#ifdef CONFIG_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF +#if ENABLE_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF if (unregister_hwif) { - no_scsi(); - printf(" attempting to unregister hwif#%u\n", hwif); - if (ioctl(fd, HDIO_UNREGISTER_HWIF, hwif)) - bb_perror_msg(" HDIO_UNREGISTER_HWIF failed"); + printf(" attempting to unregister hwif#%lu\n", hwif); + ioctl_or_warn(fd, HDIO_UNREGISTER_HWIF, (int *)(unsigned long)hwif); } #endif -#ifdef CONFIG_FEATURE_HDPARM_HDIO_SCAN_HWIF +#if ENABLE_FEATURE_HDPARM_HDIO_SCAN_HWIF if (scan_hwif) { - int args[3]; - no_scsi(); - printf(" attempting to scan hwif (0x%x, 0x%x, %u)\n", hwif_data, hwif_ctrl, hwif_irq); + printf(" attempting to scan hwif (0x%lx, 0x%lx, %lu)\n", hwif_data, hwif_ctrl, hwif_irq); args[0] = hwif_data; args[1] = hwif_ctrl; args[2] = hwif_irq; - if (ioctl(fd, HDIO_SCAN_HWIF, args)) - bb_perror_msg(" HDIO_SCAN_HWIF failed"); + ioctl_or_warn(fd, HDIO_SCAN_HWIF, args); + args[0] = WIN_SETFEATURES; + args[1] = 0; } #endif if (set_piomode) { - no_scsi(); - no_xt(); if (noisy_piomode) { + printf(" attempting to "); if (piomode == 255) - printf(" attempting to auto-tune PIO mode\n"); + printf("auto-tune PIO mode\n"); else if (piomode < 100) - printf(" attempting to set PIO mode to %d\n", piomode); + printf("set PIO mode to %d\n", piomode); else if (piomode < 200) - printf(" attempting to set MDMA mode to %d\n", (piomode-100)); + printf("set MDMA mode to %d\n", (piomode-100)); else - printf(" attempting to set UDMA mode to %d\n", (piomode-200)); + printf("set UDMA mode to %d\n", (piomode-200)); } - if (ioctl(fd, HDIO_SET_PIO_MODE, piomode)) - bb_perror_msg(" HDIO_SET_PIO_MODE failed"); + ioctl_or_warn(fd, HDIO_SET_PIO_MODE, (int *)(unsigned long)piomode); } if (set_io32bit) { - no_scsi(); - no_xt(); - if (get_io32bit) - printf(" setting 32-bit IO_support flag to %ld\n", io32bit); - if (ioctl(fd, HDIO_SET_32BIT, io32bit)) - bb_perror_msg(" HDIO_SET_32BIT failed"); + print_flag(get_io32bit, "32-bit IO_support flag", io32bit); + ioctl_or_warn(fd, HDIO_SET_32BIT, (int *)io32bit); } if (set_mult) { - no_scsi(); - no_xt(); - if (get_mult) - printf(" setting multcount to %ld\n", mult); - if (ioctl(fd, HDIO_SET_MULTCOUNT, mult)) - bb_perror_msg(" HDIO_SET_MULTCOUNT failed"); -#ifndef HDIO_DRIVE_CMD - else force_operation = 1; + print_flag(get_mult, "multcount", mult); +#ifdef HDIO_DRIVE_CMD + ioctl_or_warn(fd, HDIO_SET_MULTCOUNT, (void *)mult); +#else + force_operation |= (!ioctl_or_warn(fd, HDIO_SET_MULTCOUNT, (void *)mult)); #endif } if (set_readonly) { - if (get_readonly) { - printf(" setting readonly to %ld", readonly); - on_off(readonly); - } - if (ioctl(fd, BLKROSET, &readonly)) - bb_perror_msg(" BLKROSET failed"); + print_flag_on_off(get_readonly, "readonly", readonly); + ioctl_or_warn(fd, BLKROSET, &readonly); } if (set_unmask) { - no_scsi(); - no_xt(); - if (get_unmask) { - printf(" setting unmaskirq to %ld", unmask); - on_off(unmask); - } - if (ioctl(fd, HDIO_SET_UNMASKINTR, unmask)) - bb_perror_msg(" HDIO_SET_UNMASKINTR failed"); + print_flag_on_off(get_unmask, "unmaskirq", unmask); + ioctl_or_warn(fd, HDIO_SET_UNMASKINTR, (int *)unmask); } +#if ENABLE_FEATURE_HDPARM_HDIO_GETSET_DMA if (set_dma) { - no_scsi(); - if (get_dma) { - printf(" setting using_dma to %ld", dma); - on_off(dma); - } - if (ioctl(fd, HDIO_SET_DMA, dma)) - bb_perror_msg(" HDIO_SET_DMA failed"); + print_flag_on_off(get_dma, "using_dma", dma); + ioctl_or_warn(fd, HDIO_SET_DMA, (int *)dma); } +#endif /* FEATURE_HDPARM_HDIO_GETSET_DMA */ +#ifdef HDIO_SET_QDMA if (set_dma_q) { - no_scsi(); - if (get_dma_q) { - printf(" setting DMA queue_depth to %ld", dma_q); - on_off(dma_q); - } - if (ioctl(fd, HDIO_SET_QDMA, dma_q)) - bb_perror_msg(" HDIO_SET_QDMA failed"); + print_flag_on_off(get_dma_q, "DMA queue_depth", dma_q); + ioctl_or_warn(fd, HDIO_SET_QDMA, (int *)dma_q); } +#endif if (set_nowerr) { - no_scsi(); - no_xt(); - if (get_nowerr) { - printf(" setting nowerr to %ld", nowerr); - on_off(nowerr); - } - if (ioctl(fd, HDIO_SET_NOWERR, nowerr)) - bb_perror_msg(" HDIO_SET_NOWERR failed"); + print_flag_on_off(get_nowerr, "nowerr", nowerr); + ioctl_or_warn(fd, HDIO_SET_NOWERR, (int *)nowerr); } if (set_keep) { - no_scsi(); - no_xt(); - if (get_keep) { - printf(" setting keep_settings to %ld", keep); - on_off(keep); - } - if (ioctl(fd, HDIO_SET_KEEPSETTINGS, keep)) - bb_perror_msg(" HDIO_SET_KEEPSETTINGS failed"); + print_flag_on_off(get_keep, "keep_settings", keep); + ioctl_or_warn(fd, HDIO_SET_KEEPSETTINGS, (int *)keep); } #ifdef HDIO_DRIVE_CMD if (set_doorlock) { - unsigned char args[4] = {0,0,0,0}; - no_scsi(); - no_xt(); args[0] = doorlock ? WIN_DOORLOCK : WIN_DOORUNLOCK; - if (get_doorlock) { - printf(" setting drive doorlock to %ld", doorlock); - on_off(doorlock); - } - if (ioctl(fd, HDIO_DRIVE_CMD, &args)) - bb_perror_msg(" HDIO_DRIVE_CMD(doorlock) failed"); + args[2] = 0; + print_flag_on_off(get_doorlock, "drive doorlock", doorlock); + ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args); + args[0] = WIN_SETFEATURES; } if (set_dkeep) { /* lock/unlock the drive's "feature" settings */ - unsigned char args[4] = {WIN_SETFEATURES,0,0,0}; - no_scsi(); - no_xt(); - if (get_dkeep) { - printf(" setting drive keep features to %ld", dkeep); - on_off(dkeep); - } + print_flag_on_off(get_dkeep, "drive keep features", dkeep); args[2] = dkeep ? 0x66 : 0xcc; - if (ioctl(fd, HDIO_DRIVE_CMD, &args)) - bb_perror_msg(" HDIO_DRIVE_CMD(keepsettings) failed"); + ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args); } if (set_defects) { - unsigned char args[4] = {WIN_SETFEATURES,0,0x04,0}; - no_scsi(); args[2] = defects ? 0x04 : 0x84; - if (get_defects) - printf(" setting drive defect-mgmt to %ld\n", defects); - if (ioctl(fd, HDIO_DRIVE_CMD, &args)) - bb_perror_msg(" HDIO_DRIVE_CMD(defectmgmt) failed"); + print_flag(get_defects, "drive defect-mgmt", defects); + ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args); } if (set_prefetch) { - unsigned char args[4] = {WIN_SETFEATURES,0,0xab,0}; - no_scsi(); - no_xt(); args[1] = prefetch; - if (get_prefetch) - printf(" setting drive prefetch to %ld\n", prefetch); - if (ioctl(fd, HDIO_DRIVE_CMD, &args)) - bb_perror_msg(" HDIO_DRIVE_CMD(setprefetch) failed"); + args[2] = 0xab; + print_flag(get_prefetch, "drive prefetch", prefetch); + ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args); + args[1] = 0; } if (set_xfermode) { - unsigned char args[4] = {WIN_SETFEATURES,0,3,0}; - no_scsi(); - no_xt(); args[1] = xfermode_requested; + args[2] = 3; if (get_xfermode) { - printf(" setting xfermode to %d", xfermode_requested); + print_flag(1, "xfermode", xfermode_requested); interpret_xfermode(xfermode_requested); } - if (ioctl(fd, HDIO_DRIVE_CMD, &args)) - bb_perror_msg(" HDIO_DRIVE_CMD(setxfermode) failed"); + ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args); + args[1] = 0; } if (set_lookahead) { - unsigned char args[4] = {WIN_SETFEATURES,0,0,0}; - no_scsi(); - no_xt(); args[2] = lookahead ? 0xaa : 0x55; - if (get_lookahead) { - printf(" setting drive read-lookahead to %ld", lookahead); - on_off(lookahead); - } - if (ioctl(fd, HDIO_DRIVE_CMD, &args)) - bb_perror_msg(" HDIO_DRIVE_CMD(setreadahead) failed"); + print_flag_on_off(get_lookahead, "drive read-lookahead", lookahead); + ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args); } if (set_apmmode) { - unsigned char args[4] = {WIN_SETFEATURES,0,0,0}; - no_scsi(); - if (apmmode<1) apmmode=1; - if (apmmode>255) apmmode=255; - if (get_apmmode) - printf(" setting Advanced Power Management level to"); - if (apmmode==255) { - /* disable Advanced Power Management */ - args[2] = 0x85; /* feature register */ - if (get_apmmode) printf(" disabled\n"); - } else { - /* set Advanced Power Management mode */ - args[2] = 0x05; /* feature register */ - args[1] = apmmode; /* sector count register */ - if (get_apmmode) printf(" 0x%02lX (%ld)\n",apmmode,apmmode); - } - if (ioctl(fd, HDIO_DRIVE_CMD, &args)) - bb_perror_msg(" HDIO_DRIVE_CMD failed"); - } - if (set_wcache) { + args[2] = (apmmode == 255) ? 0x85 /* disable */ : 0x05 /* set */; /* feature register */ + args[1] = apmmode; /* sector count register 1-255 */ + if (get_apmmode) + printf(" setting APM level to %s 0x%02lX (%ld)\n", (apmmode == 255) ? "disabled" : "", apmmode, apmmode); + ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args); + args[1] = 0; + } + if (set_wcache) { #ifdef DO_FLUSHCACHE #ifndef WIN_FLUSHCACHE #define WIN_FLUSHCACHE 0xe7 #endif - unsigned char flushcache[4] = {WIN_FLUSHCACHE,0,0,0}; #endif /* DO_FLUSHCACHE */ - unsigned char args[4] = {WIN_SETFEATURES,0,0,0}; - no_scsi(); - no_xt(); args[2] = wcache ? 0x02 : 0x82; - if (get_wcache) { - printf(" setting drive write-caching to %ld", wcache); - on_off(wcache); - } + print_flag_on_off(get_wcache, "drive write-caching", wcache); #ifdef DO_FLUSHCACHE - if (!wcache && ioctl(fd, HDIO_DRIVE_CMD, &flushcache)) - bb_perror_msg (" HDIO_DRIVE_CMD(flushcache) failed"); + if (!wcache) + ioctl_or_warn(fd, HDIO_DRIVE_CMD, &flushcache); #endif /* DO_FLUSHCACHE */ - if (ioctl(fd, HDIO_DRIVE_CMD, &args)) - bb_perror_msg(" HDIO_DRIVE_CMD(setcache) failed"); + ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args); #ifdef DO_FLUSHCACHE - if (!wcache && ioctl(fd, HDIO_DRIVE_CMD, &flushcache)) - bb_perror_msg (" HDIO_DRIVE_CMD(flushcache) failed"); + if (!wcache) + ioctl_or_warn(fd, HDIO_DRIVE_CMD, &flushcache); #endif /* DO_FLUSHCACHE */ } + + /* In code below, we do not preserve args[0], but the rest + is preserved, including args[2] */ + args[2] = 0; + if (set_standbynow) { #ifndef WIN_STANDBYNOW1 #define WIN_STANDBYNOW1 0xE0 @@ -1977,14 +1690,9 @@ static void process_dev (char *devname) #ifndef WIN_STANDBYNOW2 #define WIN_STANDBYNOW2 0x94 #endif - unsigned char args1[4] = {WIN_STANDBYNOW1,0,0,0}; - unsigned char args2[4] = {WIN_STANDBYNOW2,0,0,0}; - no_scsi(); - if (get_standbynow) - printf(" issuing standby command\n"); - if (ioctl(fd, HDIO_DRIVE_CMD, &args1) - && ioctl(fd, HDIO_DRIVE_CMD, &args2)) - bb_perror_msg(" HDIO_DRIVE_CMD(standby) failed"); + if (get_standbynow) printf(" issuing standby command\n"); + args[0] = WIN_STANDBYNOW1; + ioctl_alt_or_warn(HDIO_DRIVE_CMD, args, WIN_STANDBYNOW2); } if (set_sleepnow) { #ifndef WIN_SLEEPNOW1 @@ -1993,166 +1701,111 @@ static void process_dev (char *devname) #ifndef WIN_SLEEPNOW2 #define WIN_SLEEPNOW2 0x99 #endif - unsigned char args1[4] = {WIN_SLEEPNOW1,0,0,0}; - unsigned char args2[4] = {WIN_SLEEPNOW2,0,0,0}; - no_scsi(); - if (get_sleepnow) - printf(" issuing sleep command\n"); - if (ioctl(fd, HDIO_DRIVE_CMD, &args1) - && ioctl(fd, HDIO_DRIVE_CMD, &args2)) - bb_perror_msg(" HDIO_DRIVE_CMD(sleep) failed"); + if (get_sleepnow) printf(" issuing sleep command\n"); + args[0] = WIN_SLEEPNOW1; + ioctl_alt_or_warn(HDIO_DRIVE_CMD, args, WIN_SLEEPNOW2); } if (set_seagate) { - unsigned char args[4] = {0xfb,0,0,0}; - no_scsi(); - no_xt(); - if (get_seagate) - printf(" disabling Seagate auto powersaving mode\n"); - if (ioctl(fd, HDIO_DRIVE_CMD, &args)) - bb_perror_msg(" HDIO_DRIVE_CMD(seagatepwrsave) failed"); + args[0] = 0xfb; + if (get_seagate) printf(" disabling Seagate auto powersaving mode\n"); + ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args); } if (set_standby) { - unsigned char args[4] = {WIN_SETIDLE1,standby_requested,0,0}; - no_scsi(); - no_xt(); + args[0] = WIN_SETIDLE1; + args[1] = standby_requested; if (get_standby) { - printf(" setting standby to %lu", standby_requested); + print_flag(1, "standby", standby_requested); interpret_standby(standby_requested); } - if (ioctl(fd, HDIO_DRIVE_CMD, &args)) - bb_perror_msg(" HDIO_DRIVE_CMD(setidle1) failed"); + ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args); + args[1] = 0; } #else /* HDIO_DRIVE_CMD */ if (force_operation) { char buf[512]; - flush_buffer_cache(fd); + flush_buffer_cache(); if (-1 == read(fd, buf, sizeof(buf))) - bb_perror_msg(" access failed"); + bb_perror_msg("read(%d bytes) failed (rc=-1)", sizeof(buf)); } #endif /* HDIO_DRIVE_CMD */ - if (!flagcount) - verbose = 1; - - if ((verbose && !is_scsi_hd && !is_xt_hd) || get_mult || get_identity) { - no_scsi(); + if (get_mult || get_identity) { multcount = -1; if (ioctl(fd, HDIO_GET_MULTCOUNT, &multcount)) { - if ((verbose && !is_xt_hd) || get_mult) - bb_perror_msg(" HDIO_GET_MULTCOUNT failed"); - } else if (verbose | get_mult) { - printf(" multcount = %2ld", multcount); - on_off(multcount); - } - } - if ((verbose && !is_scsi_hd && !is_xt_hd) || get_io32bit) { - no_scsi(); - no_xt(); - if (ioctl(fd, HDIO_GET_32BIT, &parm)) - bb_perror_msg(" HDIO_GET_32BIT failed"); - else { - printf(" IO_support =%3ld (", parm); - switch (parm) { - case 0: printf("default "); - case 2: printf("16-bit)\n"); - break; - case 1: printf("32-bit)\n"); - break; - case 3: printf("32-bit w/sync)\n"); - break; - case 8: printf("Request-Queue-Bypass)\n"); - break; - default:printf("\?\?\?)\n"); - } + if (get_mult && ENABLE_IOCTL_HEX2STR_ERROR) /* To be coherent with ioctl_or_warn. */ + bb_perror_msg("HDIO_GET_MULTCOUNT"); + else + bb_perror_msg("ioctl %#x failed", HDIO_GET_MULTCOUNT); + } else if (get_mult) { + printf(fmt, "multcount", multcount); + on_off(multcount != 0); + } + } + if (get_io32bit) { + if (!ioctl_or_warn(fd, HDIO_GET_32BIT, &parm)) { + printf(" IO_support\t=%3ld (", parm); + if (parm == 0) + printf("default 16-bit)\n"); + else if (parm == 2) + printf("16-bit)\n"); + else if (parm == 1) + printf("32-bit)\n"); + else if (parm == 3) + printf("32-bit w/sync)\n"); + else if (parm == 8) + printf("Request-Queue-Bypass)\n"); + else + printf("\?\?\?)\n"); } } - if ((verbose && !is_scsi_hd && !is_xt_hd) || get_unmask) { - no_scsi(); - no_xt(); - if (ioctl(fd, HDIO_GET_UNMASKINTR, &parm)) - bb_perror_msg(" HDIO_GET_UNMASKINTR failed"); - else { - printf(" unmaskirq = %2ld", parm); - on_off(parm); - } + if (get_unmask) { + if (!ioctl_or_warn(fd, HDIO_GET_UNMASKINTR, &parm)) + print_value_on_off("unmaskirq", parm); } -#ifdef CONFIG_FEATURE_HDPARM_HDIO_GET_DMA - if ((verbose && !is_scsi_hd) || get_dma) { - no_scsi(); - if (ioctl(fd, HDIO_GET_DMA, &parm)) - bb_perror_msg(" HDIO_GET_DMA failed"); - else { - printf(" using_dma = %2ld", parm); + +#if ENABLE_FEATURE_HDPARM_HDIO_GETSET_DMA + if (get_dma) { + if (!ioctl_or_warn(fd, HDIO_GET_DMA, &parm)) { + printf(fmt, "using_dma", parm); if (parm == 8) printf(" (DMA-Assisted-PIO)\n"); else - on_off(parm); + on_off(parm != 0); } } #endif +#ifdef HDIO_GET_QDMA if (get_dma_q) { - no_scsi(); - if(ioctl(fd, HDIO_GET_QDMA, &parm)) { - bb_perror_msg(" HDIO_GET_QDMA failed"); - } else { - printf(" queue_depth = %2ld", parm); - on_off(parm); - } + if (!ioctl_or_warn(fd, HDIO_GET_QDMA, &parm)) + print_value_on_off("queue_depth", parm); } - if ((verbose && !is_scsi_hd && !is_xt_hd) || get_keep) { - no_scsi(); - no_xt(); - if (ioctl(fd, HDIO_GET_KEEPSETTINGS, &parm)) - bb_perror_msg(" HDIO_GET_KEEPSETTINGS failed"); - else { - printf(" keepsettings = %2ld", parm); - on_off(parm); - } +#endif + if (get_keep) { + if (!ioctl_or_warn(fd, HDIO_GET_KEEPSETTINGS, &parm)) + print_value_on_off("keepsettings", parm); } if (get_nowerr) { - no_scsi(); - no_xt(); - if (ioctl(fd, HDIO_GET_NOWERR, &parm)) - bb_perror_msg(" HDIO_GET_NOWERR failed"); - else { - printf(" nowerr = %2ld", parm); - on_off(parm); - } + if (!ioctl_or_warn(fd, HDIO_GET_NOWERR, &parm)) + print_value_on_off("nowerr", parm); } - if (verbose || get_readonly) { - if (ioctl(fd, BLKROGET, &parm)) - bb_perror_msg(" BLKROGET failed"); - else { - printf(" readonly = %2ld", parm); - on_off(parm); - } + if (get_readonly) { + if (!ioctl_or_warn(fd, BLKROGET, &parm)) + print_value_on_off("readonly", parm); } - if ((verbose && !is_scsi_hd) || get_readahead) { - if (ioctl(fd, BLKRAGET, &parm)) - bb_perror_msg(" BLKRAGET failed"); - else { - printf(" readahead = %2ld", parm); - on_off(parm); - } + if (get_readahead) { + if (!ioctl_or_warn(fd, BLKRAGET, &parm)) + print_value_on_off("readahead", parm); } - if (verbose || get_geom) { - static const char msg[] = " geometry = %u/%u/%u, sectors = %ld, start = %ld\n"; - static struct hd_geometry g; -#ifdef HDIO_GETGEO_BIG - static struct hd_big_geometry bg; -#endif + if (get_geom) { + if (!ioctl_or_warn(fd, BLKGETSIZE, &parm)) { + struct hd_geometry g; - if (ioctl(fd, BLKGETSIZE, &parm)) - bb_perror_msg(" BLKGETSIZE failed"); -#ifdef HDIO_GETGEO_BIG - else if (!ioctl(fd, HDIO_GETGEO_BIG, &bg)) - printf(msg, bg.cylinders, bg.heads, bg.sectors, parm, bg.start); -#endif - else if (ioctl(fd, HDIO_GETGEO, &g)) - bb_perror_msg(" HDIO_GETGEO failed"); - else printf(msg, g.cylinders, g.heads, g.sectors, parm, g.start); + if (!ioctl_or_warn(fd, HDIO_GETGEO, &g)) + printf(" geometry\t= %u/%u/%u, sectors = %ld, start = %ld\n", + g.cylinders, g.heads, g.sectors, parm, g.start); + } } #ifdef HDIO_DRIVE_CMD if (get_powermode) { @@ -2162,47 +1815,38 @@ static void process_dev (char *devname) #ifndef WIN_CHECKPOWERMODE2 #define WIN_CHECKPOWERMODE2 0x98 #endif - unsigned char args[4] = {WIN_CHECKPOWERMODE1,0,0,0}; const char *state; - no_scsi(); - if (ioctl(fd, HDIO_DRIVE_CMD, &args) - && (args[0] = WIN_CHECKPOWERMODE2) /* try again with 0x98 */ - && ioctl(fd, HDIO_DRIVE_CMD, &args)) { + + args[0] = WIN_CHECKPOWERMODE1; + if (ioctl_alt_or_warn(HDIO_DRIVE_CMD, args, WIN_CHECKPOWERMODE2)) { if (errno != EIO || args[0] != 0 || args[1] != 0) state = "unknown"; else state = "sleeping"; - } else { + } else state = (args[2] == 255) ? "active/idle" : "standby"; - } + args[1] = args[2] = 0; + printf(" drive state is: %s\n", state); } #endif -#ifdef CONFIG_FEATURE_HDPARM_HDIO_DRIVE_RESET +#if ENABLE_FEATURE_HDPARM_HDIO_DRIVE_RESET if (perform_reset) { - no_scsi(); - no_xt(); - if (ioctl(fd, HDIO_DRIVE_RESET, NULL)) - bb_perror_msg(" HDIO_DRIVE_RESET failed"); + ioctl_or_warn(fd, HDIO_DRIVE_RESET, NULL); } -#endif /* CONFIG_FEATURE_HDPARM_HDIO_DRIVE_RESET */ -#ifdef CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF +#endif /* FEATURE_HDPARM_HDIO_DRIVE_RESET */ +#if ENABLE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF if (perform_tristate) { - unsigned char args[4] = {0,tristate,0,0}; - no_scsi(); - no_xt(); - if (ioctl(fd, HDIO_TRISTATE_HWIF, &args)) - bb_perror_msg(" HDIO_TRISTATE_HWIF failed"); - } -#endif /* CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF */ -#ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY + args[0] = 0; + args[1] = tristate; + ioctl_or_warn(fd, HDIO_TRISTATE_HWIF, &args); + } +#endif /* FEATURE_HDPARM_HDIO_TRISTATE_HWIF */ +#if ENABLE_FEATURE_HDPARM_GET_IDENTITY if (get_identity) { - static struct hd_driveid id; + struct hd_driveid id; - no_scsi(); - no_xt(); - - if (!ioctl(fd, HDIO_GET_IDENTITY, &id)) { + if (!ioctl(fd, HDIO_GET_IDENTITY, &id)) { if (multcount != -1) { id.multsect = multcount; id.multsect_valid |= 1; @@ -2211,455 +1855,209 @@ static void process_dev (char *devname) dump_identity(&id); } else if (errno == -ENOMSG) printf(" no identification info available\n"); + else if (ENABLE_IOCTL_HEX2STR_ERROR) /* To be coherent with ioctl_or_warn */ + bb_perror_msg("HDIO_GET_IDENTITY"); else - bb_perror_msg(" HDIO_GET_IDENTITY failed"); + bb_perror_msg("ioctl %#x failed", HDIO_GET_IDENTITY); } + if (get_IDentity) { - unsigned char args[4+512] = {WIN_IDENTIFY,0,0,1,}; - unsigned i; - no_scsi(); - no_xt(); - if (ioctl(fd, HDIO_DRIVE_CMD, &args)) { - args[0] = WIN_PIDENTIFY; - if (ioctl(fd, HDIO_DRIVE_CMD, &args)) { - bb_perror_msg(" HDIO_DRIVE_CMD(identify) failed"); - goto identify_abort; - } - } - for(i=0; i<(sizeof args)/2; i+=2) { - __le16_to_cpus((uint16_t *)(&args[i])); - } - identify((void *)&args[4], NULL); -identify_abort: ; + unsigned char args1[4+512]; /* = { ... } will eat 0.5k of rodata! */ + + memset(args1, 0, sizeof(args1)); + args1[0] = WIN_IDENTIFY; + args1[3] = 1; + if (!ioctl_alt_or_warn(HDIO_DRIVE_CMD, args1, WIN_PIDENTIFY)) + identify((void *)(args1 + 4)); } #endif -#ifdef CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF +#if ENABLE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF if (set_busstate) { - no_scsi(); if (get_busstate) { - printf(" setting bus state to %d", busstate); + print_flag(1, "bus state", busstate); bus_state_value(busstate); } - if (ioctl(fd, HDIO_SET_BUSSTATE, busstate)) - bb_perror_msg(" HDIO_SET_BUSSTATE failed"); + ioctl_or_warn(fd, HDIO_SET_BUSSTATE, (int *)(unsigned long)busstate); } -#endif -#ifdef CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF if (get_busstate) { - no_scsi(); - if (ioctl(fd, HDIO_GET_BUSSTATE, &parm)) - bb_perror_msg(" HDIO_GET_BUSSTATE failed"); - else { - printf(" busstate = %2ld", parm); + if (!ioctl_or_warn(fd, HDIO_GET_BUSSTATE, &parm)) { + printf(fmt, "bus state", parm); bus_state_value(parm); } } #endif - if (reread_partn) { - if (ioctl(fd, BLKRRPART, NULL)) { - bb_perror_msg(" BLKRRPART failed"); - } - } + if (reread_partn) + ioctl_or_warn(fd, BLKRRPART, NULL); if (do_ctimings) - time_cache (fd); + do_time(1 /*,fd*/); /* time cache */ if (do_timings) - time_device (fd); + do_time(0 /*,fd*/); /* time device */ if (do_flush) - flush_buffer_cache (fd); - close (fd); + flush_buffer_cache(); + close(fd); } -#define GET_NUMBER(flag,num) num = 0; \ - if (!*p && argc && isdigit(**argv)) \ - p = *argv++, --argc; \ - while (isdigit(*p)) { \ - flag = 1; \ - num = (num * 10) + (*p++ - '0'); \ - } - -#define GET_STRING(flag, num) tmpstr = name; \ - tmpstr[0] = '\0'; \ - if (!*p && argc && isalnum(**argv)) \ - p = *argv++, --argc; \ - while (isalnum(*p) && (tmpstr - name) < 31) { \ - tmpstr[0] = *p++; \ - tmpstr[1] = '\0'; \ - ++tmpstr; \ - } \ - num = translate_xfermode(name); \ - if (num == -1) \ - flag = 0; \ - else \ - flag = 1; - -#ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY -static int fromhex (unsigned char c) +#if ENABLE_FEATURE_HDPARM_GET_IDENTITY +static int fromhex(unsigned char c) { - if (c >= 'a' && c <= 'f') - return 10 + (c - 'a'); - if (c >= '0' && c <= '9') + if (isdigit(c)) return (c - '0'); + if (c >= 'a' && c <= 'f') + return (c - ('a' - 10)); bb_error_msg_and_die("bad char: '%c' 0x%02x", c, c); } -static int identify_from_stdin (void) +static void identify_from_stdin(void) NORETURN; +static void identify_from_stdin(void) { - unsigned short sbuf[800]; - unsigned char buf[1600], *b = (unsigned char *)buf; - int i, count = read(0, buf, 1280); - - if (count != 1280) - bb_error_msg_and_die("read(1280 bytes) failed (rc=%d)", count); - for (i = 0; count >= 4; ++i) { - sbuf[i] = (fromhex(b[0]) << 12) | (fromhex(b[1]) << 8) | (fromhex(b[2]) << 4) | fromhex(b[3]); - __le16_to_cpus((uint16_t *)(&sbuf[i])); - b += 5; - count -= 5; - } - identify(sbuf, NULL); - return 0; + uint16_t sbuf[256]; + unsigned char buf[1280]; + unsigned char *b = (unsigned char *)buf; + int i; + + xread(STDIN_FILENO, buf, 1280); + + // Convert the newline-separated hex data into an identify block. + + for (i = 0; i < 256; i++) { + int j; + for (j = 0; j < 4; j++) + sbuf[i] = (sbuf[i] << 4) + fromhex(*(b++)); + } + + // Parse the data. + + identify(sbuf); } +#else +void identify_from_stdin(void); #endif -/* our main() routine: */ -int hdparm_main(int argc, char **argv) +/* busybox specific stuff */ +static void parse_opts(smallint *get, smallint *set, unsigned long *value, int min, int max) { - char c, *p; - char *tmpstr; - char name[32]; - int neg; + if (get) { + *get = 1; + } + if (optarg) { + *set = 1; + *value = xatol_range(optarg, min, max); + } +} - ++argv; - if (!--argc) - bb_show_usage(); - while (argc--) { -#ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY - if (!strcmp("-Istdin", *argv)) { - exit(identify_from_stdin()); +static void parse_xfermode(int flag, smallint *get, smallint *set, int *value) +{ + if (flag) { + *get = 1; + if (optarg) { + *value = translate_xfermode(optarg); + *set = (*value > -1); } + } +} + +/*------- getopt short options --------*/ +static const char hdparm_options[] ALIGN1 = + "gfu::n::p:r::m::c::k::a::B:tT" + USE_FEATURE_HDPARM_GET_IDENTITY("iI") + USE_FEATURE_HDPARM_HDIO_GETSET_DMA("d::") +#ifdef HDIO_DRIVE_CMD + "S:D:P:X:K:A:L:W:CyYzZ" +#endif + USE_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF("U:") +#ifdef HDIO_GET_QDMA +#ifdef HDIO_SET_QDMA + "Q:" +#else + "Q" #endif - p = *argv++; - if (*p == '-') { - if (!*++p) - bb_show_usage(); - while ((c = *p++)) { - ++flagcount; - switch (c) { - case 'V': - bb_error_msg_and_die("%s", VERSION); - case 'v': - verbose = 1; - break; -#ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY - case 'I': - get_IDentity = 1; - break; - case 'i': - get_identity = 1; - break; #endif - case 'g': - get_geom = 1; - break; - case 'f': - do_flush = 1; - break; - case 'q': - quiet = 1; - noisy = 0; - break; - case 'u': - get_unmask = noisy; - noisy = 1; - if (!*p && argc && isdigit(**argv)) - p = *argv++, --argc; - if (*p == '0' || *p == '1') { - set_unmask = 1; - unmask = *p++ - '0'; - } - break; - case 'd': - get_dma = noisy; - noisy = 1; - if (!*p && argc && isdigit(**argv)) - p = *argv++, --argc; - if (*p >= '0' && *p <= '9') { - set_dma = 1; - dma = *p++ - '0'; - } - break; - case 'n': - get_nowerr = noisy; - noisy = 1; - if (!*p && argc && isdigit(**argv)) - p = *argv++, --argc; - if (*p == '0' || *p == '1') { - set_nowerr = 1; - nowerr = *p++ - '0'; - } - break; - case 'p': - noisy_piomode = noisy; - noisy = 1; - GET_STRING(set_piomode,piomode); - break; - case 'r': - get_readonly = noisy; - noisy = 1; - if (!*p && argc && isdigit(**argv)) - p = *argv++, --argc; - if (*p == '0' || *p == '1') { - set_readonly = 1; - readonly = *p++ - '0'; - } - break; - case 'm': - get_mult = noisy; - noisy = 1; - GET_NUMBER(set_mult,mult); - break; - case 'c': - get_io32bit = noisy; - noisy = 1; - GET_NUMBER(set_io32bit,io32bit); - break; + USE_FEATURE_HDPARM_HDIO_DRIVE_RESET("w") + USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF("x::b:") + USE_FEATURE_HDPARM_HDIO_SCAN_HWIF("R:"); +/*-------------------------------------*/ + +/* our main() routine: */ +int hdparm_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; +int hdparm_main(int argc, char **argv) +{ + int c; + int flagcount = 0; + + while ((c = getopt(argc, argv, hdparm_options)) >= 0) { + flagcount++; + USE_FEATURE_HDPARM_GET_IDENTITY(get_IDentity |= (c == 'I')); + USE_FEATURE_HDPARM_GET_IDENTITY(get_identity |= (c == 'i')); + get_geom |= (c == 'g'); + do_flush |= (c == 'f'); + if (c == 'u') parse_opts(&get_unmask, &set_unmask, &unmask, 0, 1); + USE_FEATURE_HDPARM_HDIO_GETSET_DMA(if (c == 'd') parse_opts(&get_dma, &set_dma, &dma, 0, 9)); + if (c == 'n') parse_opts(&get_nowerr, &set_nowerr, &nowerr, 0, 1); + parse_xfermode((c == 'p'), &noisy_piomode, &set_piomode, &piomode); + if (c == 'r') parse_opts(&get_readonly, &set_readonly, &readonly, 0, 1); + if (c == 'm') parse_opts(&get_mult, &set_mult, &mult, 0, INT_MAX /*32*/); + if (c == 'c') parse_opts(&get_io32bit, &set_io32bit, &io32bit, 0, INT_MAX /*8*/); + if (c == 'k') parse_opts(&get_keep, &set_keep, &keep, 0, 1); + if (c == 'a') parse_opts(&get_readahead, &set_readahead, &Xreadahead, 0, INT_MAX); + if (c == 'B') parse_opts(&get_apmmode, &set_apmmode, &apmmode, 1, 255); + do_flush |= do_timings |= (c == 't'); + do_flush |= do_ctimings |= (c == 'T'); #ifdef HDIO_DRIVE_CMD - case 'S': - get_standby = noisy; - noisy = 1; - GET_NUMBER(set_standby,standby_requested); - if (!set_standby) - bb_error_msg("-S: missing value"); - break; - - case 'D': - get_defects = noisy; - noisy = 1; - GET_NUMBER(set_defects,defects); - if (!set_defects) - bb_error_msg("-D: missing value"); - break; - case 'P': - get_prefetch = noisy; - noisy = 1; - GET_NUMBER(set_prefetch,prefetch); - if (!set_prefetch) - bb_error_msg("-P: missing value"); - break; - - case 'X': - get_xfermode = noisy; - noisy = 1; - GET_STRING(set_xfermode,xfermode_requested); - if (!set_xfermode) - bb_error_msg("-X: missing value"); - break; - - case 'K': - get_dkeep = noisy; - noisy = 1; - if (!*p && argc && isdigit(**argv)) - p = *argv++, --argc; - if (*p == '0' || *p == '1') { - set_dkeep = 1; - dkeep = *p++ - '0'; - } else - bb_error_msg("-K: missing value (0/1)"); - break; - - case 'A': - get_lookahead = noisy; - noisy = 1; - if (!*p && argc && isdigit(**argv)) - p = *argv++, --argc; - if (*p == '0' || *p == '1') { - set_lookahead = 1; - lookahead = *p++ - '0'; - } else - bb_error_msg("-A: missing value (0/1)"); - break; - - case 'L': - get_doorlock = noisy; - noisy = 1; - if (!*p && argc && isdigit(**argv)) - p = *argv++, --argc; - if (*p == '0' || *p == '1') { - set_doorlock = 1; - doorlock = *p++ - '0'; - } else - bb_error_msg("-L: missing value (0/1)"); - break; - - case 'W': - get_wcache = noisy; - noisy = 1; - if (!*p && argc && isdigit(**argv)) - p = *argv++, --argc; - if (*p == '0' || *p == '1') { - set_wcache = 1; - wcache = *p++ - '0'; - } else - bb_error_msg("-W: missing value (0/1)"); - break; - - case 'C': - get_powermode = noisy; - noisy = 1; - break; - - case 'y': - get_standbynow = noisy; - noisy = 1; - set_standbynow = 1; - break; - - case 'Y': - get_sleepnow = noisy; - noisy = 1; - set_sleepnow = 1; - break; - - case 'z': - reread_partn = 1; - break; - - case 'Z': - get_seagate = noisy; - noisy = 1; - set_seagate = 1; - break; -#endif /* HDIO_DRIVE_CMD */ - case 'k': - get_keep = noisy; - noisy = 1; - if (!*p && argc && isdigit(**argv)) - p = *argv++, --argc; - if (*p == '0' || *p == '1') { - set_keep = 1; - keep = *p++ - '0'; - } - break; -#ifdef CONFIG_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF - case 'U': - if (!*p && argc && isdigit(**argv)) - p = *argv++, --argc; - - if(! p) { - bb_error_msg_and_die("expected hwif_nr"); - } - - sscanf(p++, "%i", &hwif); - - unregister_hwif = 1; - break; -#endif /* CONFIG_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF */ -#ifdef CONFIG_FEATURE_HDPARM_HDIO_SCAN_HWIF - case 'R': - if (!*p && argc && isdigit(**argv)) - p = *argv++, --argc; - - if(! p) { - bb_error_msg_and_die("expected hwif_data"); - } - - sscanf(p++, "%i", &hwif_data); - - if (argc && isdigit(**argv)) - p = *argv++, --argc; - else { - bb_error_msg_and_die("expected hwif_ctrl"); - } - - sscanf(p, "%i", &hwif_ctrl); - - if (argc && isdigit(**argv)) - p = *argv++, --argc; - else { - bb_error_msg_and_die("expected hwif_irq"); - } - - sscanf(p, "%i", &hwif_irq); - - *p = '\0'; - - scan_hwif = 1; - break; -#endif /* CONFIG_FEATURE_HDPARM_HDIO_SCAN_HWIF */ - case 'Q': - get_dma_q = noisy; - noisy = 1; - neg = 0; - GET_NUMBER(set_dma_q, dma_q); - if (neg) - dma_q = -dma_q; - break; -#ifdef CONFIG_FEATURE_HDPARM_HDIO_DRIVE_RESET - case 'w': - perform_reset = 1; - break; -#endif /* CONFIG_FEATURE_HDPARM_HDIO_DRIVE_RESET */ -#ifdef CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF - case 'x': - if (!*p && argc && isdigit(**argv)) - p = *argv++, --argc; - if (*p == '0' || *p == '1') { - perform_tristate = 1; - tristate = *p++ - '0'; - } else - bb_error_msg("-x: missing value (0/1)"); - break; - -#endif /* CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF */ - case 'a': - get_readahead = noisy; - noisy = 1; - GET_NUMBER(set_readahead,readahead); - break; - case 'B': - get_apmmode = noisy; - noisy = 1; - GET_NUMBER(set_apmmode,apmmode); - if (!set_apmmode) - printf("-B: missing value (1-255)"); - break; - case 't': - do_timings = 1; - do_flush = 1; - break; - case 'T': - do_ctimings = 1; - do_flush = 1; - break; -#ifdef CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF - case 'b': - get_busstate = noisy; - noisy = 1; - if (!*p && argc && isdigit(**argv)) - p = *argv++, --argc; - switch (*p) { - case '0': - case '1': - case '2': - set_busstate = 1; - busstate = *p++ - '0'; - break; - default: - break; - } - break; + if (c == 'S') parse_opts(&get_standby, &set_standby, &standby_requested, 0, 255); + if (c == 'D') parse_opts(&get_defects, &set_defects, &defects, 0, INT_MAX); + if (c == 'P') parse_opts(&get_prefetch, &set_prefetch, &prefetch, 0, INT_MAX); + parse_xfermode((c == 'X'), &get_xfermode, &set_xfermode, &xfermode_requested); + if (c == 'K') parse_opts(&get_dkeep, &set_dkeep, &prefetch, 0, 1); + if (c == 'A') parse_opts(&get_lookahead, &set_lookahead, &lookahead, 0, 1); + if (c == 'L') parse_opts(&get_doorlock, &set_doorlock, &doorlock, 0, 1); + if (c == 'W') parse_opts(&get_wcache, &set_wcache, &wcache, 0, 1); + get_powermode |= (c == 'C'); + get_standbynow = set_standbynow |= (c == 'y'); + get_sleepnow = set_sleepnow |= (c == 'Y'); + reread_partn |= (c == 'z'); + get_seagate = set_seagate |= (c == 'Z'); #endif - case 'h': - default: - bb_show_usage(); - } - } - if (!argc) - bb_show_usage(); - } else { - process_dev (p); + USE_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF(if (c == 'U') parse_opts(NULL, &unregister_hwif, &hwif, 0, INT_MAX)); +#ifdef HDIO_GET_QDMA + if (c == 'Q') { +#ifdef HDIO_SET_QDMA + parse_opts(&get_dma_q, &set_dma_q, &dma_q, 0, INT_MAX); +#else + parse_opts(&get_dma_q, NULL, NULL, 0, 0); +#endif + } +#endif + USE_FEATURE_HDPARM_HDIO_DRIVE_RESET(perform_reset = (c == 'r')); + USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(if (c == 'x') parse_opts(NULL, &perform_tristate, &tristate, 0, 1)); + USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(if (c == 'b') parse_opts(&get_busstate, &set_busstate, &busstate, 0, 2)); +#if ENABLE_FEATURE_HDPARM_HDIO_SCAN_HWIF + if (c == 'R') { + parse_opts(NULL, &scan_hwif, &hwif_data, 0, INT_MAX); + hwif_ctrl = xatoi_u((argv[optind]) ? argv[optind] : ""); + hwif_irq = xatoi_u((argv[optind+1]) ? argv[optind+1] : ""); + /* Move past the 2 additional arguments */ + argv += 2; + argc -= 2; } +#endif + } + /* When no flags are given (flagcount = 0), -acdgkmnru is assumed. */ + if (!flagcount) { + get_mult = get_io32bit = get_unmask = get_keep = get_readonly = get_readahead = get_geom = 1; + USE_FEATURE_HDPARM_HDIO_GETSET_DMA(get_dma = 1); } - return 0 ; + argv += optind; + + if (!*argv) { + if (ENABLE_FEATURE_HDPARM_GET_IDENTITY && !isatty(STDIN_FILENO)) + identify_from_stdin(); /* EXIT */ + bb_show_usage(); + } + + do { + process_dev(*argv++); + } while (*argv); + + return EXIT_SUCCESS; } |