hdparm: style fixes, no code changes

1 files changed, 271 insertions, 405 deletions

diff --git a/miscutils/hdparm.c b/miscutils/hdparm.c
index eafb07898..0138eed92 100644
--- a/miscutils/hdparm.c
+++ b/miscutils/hdparm.c
@@ -127,7 +127,7 @@
 
 #define CDROM 0x0005
 
-#ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY
+#if ENABLE_FEATURE_HDPARM_GET_IDENTITY
 static const char * const pkt_str[] = {
 	"Direct-access device",			/* word 0, bits 12-8 = 00 */
 	"Sequential-access device",		/* word 0, bits 12-8 = 01 */
@@ -239,7 +239,7 @@ static const char * const ata1_cfg_str[] = {			/* word 0 in ATA-1 mode */
 
 /* word 81: minor version number */
 #define MINOR_MAX		0x22
-#ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY
+#if ENABLE_FEATURE_HDPARM_GET_IDENTITY
 static const char *minor_str[MINOR_MAX+2] = {			/* word 81 value: */
 	"Unspecified",					/* 0x0000	*/
 	"ATA-1 X3T9.2 781D prior to rev.4",	/* 0x0001	*/
@@ -326,7 +326,7 @@ static const char actual_ver[MINOR_MAX+2] = {
 #define SUPPORT_48_BIT		0x0400
 #define NUM_CMD_FEAT_STR	48
 
-#ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY
+#if ENABLE_FEATURE_HDPARM_GET_IDENTITY
 static const char * const cmd_feat_str[] = {
 	"",					/* word 82 bit 15: obsolete  */
 	"NOP cmd",				/* word 82 bit 14 */
@@ -413,7 +413,7 @@ void identify_from_stdin(void);
 #define SECU_ENABLED	0x0002
 #define SECU_LEVEL		0x0010
 #define NUM_SECU_STR	6
-#ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY
+#if ENABLE_FEATURE_HDPARM_GET_IDENTITY
 static const char * const secu_str[] = {
 	"supported",			/* word 128, bit 0 */
 	"enabled",			/* word 128, bit 1 */
@@ -480,7 +480,7 @@ static void bb_ioctl_on_off(int fd, int request, void *argp, const char *string,
 	}
 }
 
-#ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY
+#if ENABLE_FEATURE_HDPARM_GET_IDENTITY
 static void print_ascii(uint16_t *p, uint8_t length);
 
 static void xprint_ascii(uint16_t *val ,int i, const char *string, int n)
@@ -493,26 +493,23 @@ static void xprint_ascii(uint16_t *val ,int i, const char *string, int n)
 #endif
 /* end of busybox specific stuff */
 
-#ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY
+#if ENABLE_FEATURE_HDPARM_GET_IDENTITY
 static uint8_t mode_loop(uint16_t mode_sup, uint16_t mode_sel, int cc, uint8_t *have_mode)
 {
 	uint16_t ii;
 	uint8_t err_dma = 0;
 
-	for (ii = 0; ii <= MODE_MAX; ii++)
-	{
-		if (mode_sel & 0x0001)
-		{
+	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)
+		} else if (mode_sup & 0x0001)
 			printf("%cdma%u ",cc,ii);
 
-		mode_sup >>=1;
-		mode_sel >>=1;
+		mode_sup >>= 1;
+		mode_sel >>= 1;
 	}
 	return err_dma;
 }
@@ -522,13 +519,13 @@ static void print_ascii(uint16_t *p, uint8_t length) {
 	char cl;
 
 	/* find first non-space & print it */
-	for (ii = 0; ii< length; ii++)
-	{
-		if (((char) 0x00ff&((*p)>>8)) != ' ')
+	for (ii = 0; ii < length; ii++) {
+		if ((char)((*p)>>8) != ' ')
 			break;
-		if ((cl = (char) 0x00ff&(*p)) != ' ')
-		{
-			if (cl != '\0') printf("%c",cl);
+		cl = (char)(*p);
+		if (cl != ' ') {
+			if (cl != '\0')
+				printf("%c", cl);
 			p++;
 			ii++;
 			break;
@@ -536,11 +533,10 @@ static void print_ascii(uint16_t *p, uint8_t length) {
 		p++;
 	}
 	/* print the rest */
-	for (; ii< length; ii++)
-	{
+	for (; ii< length; ii++) {
 		if (!(*p))
 			break; /* some older devices have NULLs */
-		printf("%c%c",(char)0x00ff&((*p)>>8),(char)(*p)&0x00ff);
+		printf("%c%c", (char)((*p)>>8), (char)(*p));
 		p++;
 	}
 	puts("");
@@ -565,31 +561,26 @@ static void identify(uint16_t *id_supplied)
 	if (BB_BIG_ENDIAN) {
 		swab(id_supplied, buf, sizeof(buf));
 		val = buf;
-	} else val = id_supplied;
+	} else
+		val = id_supplied;
 
 	chksum &= 0xff;
 
 	/* check if we recognise the device type */
 	puts("");
-	if (!(val[GEN_CONFIG] & NOT_ATA))
-	{
+	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]);
 		like_std = 3;
-	}
-	else
+	} 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");
 
@@ -601,9 +592,9 @@ static void identify(uint16_t *id_supplied)
 	 * 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) )
-	{
+	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");
@@ -621,10 +612,8 @@ static void identify(uint16_t *id_supplied)
 	/* 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 (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: %s ",minor_str[val[MINOR]]);
@@ -633,18 +622,14 @@ static void identify(uint16_t *id_supplied)
 		/* looks like when they up-issue the std, they obsolete one;
 		 * 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;
 					}
@@ -664,62 +649,54 @@ static void identify(uint16_t *id_supplied)
 			((((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) ) ) )
-		{
+			(	val[CMDS_SUPP_2] & CMDS_W84) ) )
+		) {
 			like_std = 6;
-		}
-		else if (((std == 4) || (!std && (like_std < 5))) &&
+		} 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))) &&
+		} 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) ) )
-		{
+				((	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))) &&
+		} 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);
+			printf("\n\tLikely used: %u\n", like_std);
 		else if (like_std > std)
-			printf("& some of %u\n",like_std);
+			printf("& some of %u\n", like_std);
 		else
 			puts("");
-	}
-	else
-	{
+	} else {
 		/* TBD: do CDROM stuff more thoroughly.  For now... */
 		kk = 0;
-		if (val[CDR_MINOR] == 9)
-		{
+		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++)
-			{
+			for (ii = 1; ii < 15; ii++) {
 				if (jj & 0x0001) printf("-%u ", ii);
 				jj >>= 1;
 			}
@@ -734,17 +711,14 @@ static void identify(uint16_t *id_supplied)
 
 	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++)
-		{
+		for (ii = 1; ii < 15; ii++) {
 			if (jj & 0x0001) printf("\t%s\n",ata1_cfg_str[ii]);
 			jj >>=1;
 		}
 	}
-	if (dev == ATAPI_DEV)
-	{
+	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)
@@ -762,16 +736,13 @@ static void identify(uint16_t *id_supplied)
 		else
 			strng = "Unknown";
 		puts(strng);
-	}
-	else
-	{
+	} else {
 		/* addressing...CHS? See section 6.2 of ATA specs 4 or 5 */
 		ll = (uint32_t)val[LBA_SECTS_MSB] << 16 | val[LBA_SECTS_LSB];
 		mm = 0; bbbig = 0;
 		if ( (ll > 0x00FBFC10) && (!val[LCYLS]))
 			printf("\tCHS addressing not supported\n");
-		else
-		{
+		else {
 			jj = val[WHATS_VALID] & OK_W54_58;
 			printf("\tLogical\t\tmax\tcurrent\n\tcylinders\t%u\t%u\n\theads\t\t%u\t%u\n\tsectors/track\t%u\t%u\n\t--\n",
 					val[LCYLS],jj?val[LCYLS_CUR]:0, val[LHEADS],jj?val[LHEADS_CUR]:0, val[LSECTS],jj?val[LSECTS_CUR]:0);
@@ -779,12 +750,10 @@ static void identify(uint16_t *id_supplied)
 			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)
-			{
+			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))
@@ -795,9 +764,9 @@ static void identify(uint16_t *id_supplied)
 		}
 		/* 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) )
-		{
+		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 |
@@ -820,73 +789,61 @@ static void identify(uint16_t *id_supplied)
 	/* hw support of commands (capabilities) */
 	printf("Capabilities:\n\t");
 
-	if (dev == ATAPI_DEV)
-	{
+	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)
-	{
+	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
+	} else
 		printf("no IORDY\n");
 
-	if ((like_std == 1) && val[BUF_TYPE])
-	{
+	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)))
-	{
+	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]))
-	{
+	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))
-	{
+	if ((eqpt != CDROM) && (like_std > 3)) {
 		printf("\tQueue depth: %u\n",(val[QUEUE_DEPTH] & DEPTH_BITS)+1);
 	}
 
-	if (dev == ATA_DEV)
-	{
+	if (dev == ATA_DEV) {
 		if (like_std == 1)
 			printf("\tCan%s perform double-word IO\n",(!val[DWORD_IO]) ?"not":"");
-		else
-		{
+		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
-			  puts("");
+				puts("");
 		}
 		printf("\tR/W multiple sector transfer: ");
 		if ((like_std < 3) && !(val[SECTOR_XFER_MAX] & SECTOR_XFER))
 			printf("not supported\n");
-		else
-		{
+		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("\tAdvancedPM level: ");
-			if ( (val[ADV_PWR] & 0xFF00) == 0x4000 )
-			{
+			if ((val[ADV_PWR] & 0xFF00) == 0x4000) {
 				uint8_t apm_level = val[ADV_PWR] & 0x00FF;
 				printf("%u (0x%x)\n", apm_level, apm_level);
 			}
@@ -897,15 +854,12 @@ static void identify(uint16_t *id_supplied)
 			printf("\tRecommended acoustic management value: %u, current value: %u\n",
 									(val[ACOUSTIC] >> 8) & 0x00ff, val[ACOUSTIC] & 0x00ff);
 		}
-	}
-	else
-	{
+	} else {
 		 /* ATAPI */
 		if (eqpt != CDROM && (val[CAPAB_0] & SWRST_REQ))
 			printf("\tATA sw reset required\n");
 
-		if (val[PKT_REL] || val[SVC_NBSY])
-		{
+		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]);
@@ -917,24 +871,20 @@ static void identify(uint16_t *id_supplied)
 	printf("\tDMA: ");
 	if (!(val[CAPAB_0] & DMA_SUP))
 		printf("not supported\n");
-	else
-	{
+	else {
 		if (val[DMA_MODE] && !val[SINGLE_DMA] && !val[MULTI_DMA])
 			printf(" sdma%u\n",(val[DMA_MODE] & MODE) >> 8);
-		if (val[SINGLE_DMA])
-		{
+		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])
-		{
+		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])
-		{
+		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);
@@ -945,9 +895,9 @@ static void identify(uint16_t *id_supplied)
 		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]))
-		{
+		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]);
@@ -959,29 +909,22 @@ static void identify(uint16_t *id_supplied)
 	printf("\tPIO: ");
 	/* 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++)
-		{
+		for (ii = 0; ii <= PIO_MODE_MAX ; ii++) {
 			if (jj & 0x0001) printf("pio%d ",ii);
 			jj >>=1;
 		}
 		puts("");
-	}
-	else if (((min_std < 5) || (eqpt == CDROM)) && (val[PIO_MODE] & MODE) )
-	{
+	} else if (((min_std < 5) || (eqpt == CDROM)) && (val[PIO_MODE] & MODE)) {
 		for (ii = 0; ii <= val[PIO_MODE]>>8; ii++)
 			printf("pio%d ",ii);
 		puts("");
-	}
-	else
+	} else
 		printf("unknown\n");
 
-	if (val[WHATS_VALID] & OK_W64_70)
-	{
-		if (val[PIO_NO_FLOW] || val[PIO_FLOW])
-		{
+	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]);
@@ -989,25 +932,21 @@ static void identify(uint16_t *id_supplied)
 		}
 	}
 
-	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'))
-			{
+		for (ii = 0; ii < NUM_CMD_FEAT_STR; ii++) {
+			if ((jj & 0x8000) && (*cmd_feat_str[ii] != '\0')) {
 				printf("\t%s\t%s\n", (kk & 0x8000) ? "   *" : "", cmd_feat_str[ii]);
 			}
-			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 (ii == 31) {
 				if ((val[CMDS_SUPP_2] & VALID) != VALID_VAL)
 					ii +=16;
 			}
@@ -1017,31 +956,26 @@ static void identify(uint16_t *id_supplied)
 	if ((val[RM_STAT] & RM_STAT_BITS) == RM_STAT_SUP)
 		printf("\t%s supported\n", cmd_feat_str[27]);
 
-
 	/* security */
-	if ((eqpt != CDROM) && (like_std > 3) &&
-	   (val[SECU_STATUS] || val[ERASE_TIME] || val[ENH_ERASE_TIME]))
-	{
+	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) {
+			for (ii = 0; ii < NUM_SECU_STR; ii++) {
 				printf("\t%s\t%s\n", (!(jj & 0x0001)) ? "not" : "",  secu_str[ii]);
 				jj >>=1;
 			}
-			if (val[SECU_STATUS] & SECU_ENABLED)
-			{
+			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)
-		{
+		if (jj || kk) {
 			printf("\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 ");
@@ -1051,8 +985,7 @@ static void identify(uint16_t *id_supplied)
 
 	/* reset result */
 	jj = val[HWRST_RSLT];
-	if ((jj & VALID) == VALID_VAL)
-	{
+	if ((jj & VALID) == VALID_VAL) {
 		if (!(oo = (jj & RST0)))
 			jj >>= 8;
 		if ((jj & DEV_DET) == JUMPER_VAL)
@@ -1066,17 +999,15 @@ static void identify(uint16_t *id_supplied)
 	}
 
 	/* more stuff from std 5 */
-	if ((like_std > 4) && (eqpt != CDROM))
-	{
-		if (val[CFA_PWR_MODE] & VALID_W160)
-		{
+	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" : "");
+					(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[CFA_PWR_MODE] & MAX_AMPS)
+				printf("\tMaximum current = %uma\n",val[CFA_PWR_MODE] & MAX_AMPS);
 		}
-		if ((val[INTEGRITY] & SIG) == SIG_VAL)
-		{
+		if ((val[INTEGRITY] & SIG) == SIG_VAL) {
 			printf("Checksum: %scorrect\n", chksum ? "in" : "");
 		}
 	}
@@ -1092,7 +1023,7 @@ static unsigned long set_readahead, get_readahead, Xreadahead;
 static unsigned long set_readonly, get_readonly, readonly;
 static unsigned long set_unmask, get_unmask, unmask;
 static unsigned long set_mult, get_mult, mult;
-#ifdef CONFIG_FEATURE_HDPARM_HDIO_GETSET_DMA
+#if ENABLE_FEATURE_HDPARM_HDIO_GETSET_DMA
 static unsigned long set_dma, get_dma, dma;
 #endif
 static unsigned long set_dma_q, get_dma_q, dma_q;
@@ -1117,30 +1048,30 @@ static unsigned long set_sleepnow, get_sleepnow;
 static unsigned long get_powermode;
 static unsigned long set_apmmode, get_apmmode, apmmode;
 #endif
-#ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY
+#if ENABLE_FEATURE_HDPARM_GET_IDENTITY
 static int get_IDentity;
 #endif
-#ifdef CONFIG_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF
-static unsigned long	unregister_hwif;
-static unsigned long	hwif;
+#if ENABLE_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF
+static unsigned long unregister_hwif;
+static unsigned long hwif;
 #endif
-#ifdef CONFIG_FEATURE_HDPARM_HDIO_SCAN_HWIF
+#if ENABLE_FEATURE_HDPARM_HDIO_SCAN_HWIF
 static unsigned long scan_hwif;
 static unsigned long hwif_data;
 static unsigned long hwif_ctrl;
 static unsigned long hwif_irq;
 #endif
-#ifdef CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF
-static unsigned long	set_busstate, get_busstate, busstate;
+#if ENABLE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF
+static unsigned long set_busstate, get_busstate, busstate;
 #endif
-static int	reread_partn;
+static int reread_partn;
 
-#ifdef CONFIG_FEATURE_HDPARM_HDIO_DRIVE_RESET
-static int	perform_reset;
-#endif /* CONFIG_FEATURE_HDPARM_HDIO_DRIVE_RESET */
-#ifdef CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF
-static unsigned long	perform_tristate,	tristate;
-#endif /* CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF */
+#if ENABLE_FEATURE_HDPARM_HDIO_DRIVE_RESET
+static int perform_reset;
+#endif /* FEATURE_HDPARM_HDIO_DRIVE_RESET */
+#if ENABLE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF
+static unsigned long perform_tristate, tristate;
+#endif /* FEATURE_HDPARM_HDIO_TRISTATE_HWIF */
 
 // Historically, if there was no HDIO_OBSOLETE_IDENTITY, then
 // then the HDIO_GET_IDENTITY only returned 142 bytes.
@@ -1153,7 +1084,7 @@ static unsigned long	perform_tristate,	tristate;
 // On a really old system, it will not, and we will be confused.
 // Too bad, really.
 
-#ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY
+#if ENABLE_FEATURE_HDPARM_GET_IDENTITY
 static const char * const cfg_str[] =
 {	"",	     "HardSect",   "SoftSect",   "NotMFM",
 	"HdSw>15uSec", "SpinMotCtl", "Fixed",     "Removeable",
@@ -1166,7 +1097,7 @@ static const char * const BuffType[] = {"Unknown", "1Sect", "DualPort", "DualPor
 static void dump_identity(const struct hd_driveid *id)
 {
 	int i;
-	const unsigned short int *id_regs= (const void*) id;
+	const unsigned short int *id_regs = (const void*) id;
 
 	printf("\n Model=%.40s, FwRev=%.8s, SerialNo=%.20s\n Config={",
 				id->model, id->fw_rev, id->serial_no);
@@ -1180,10 +1111,9 @@ static void dump_identity(const struct hd_driveid *id)
 				id->sector_bytes, id->ecc_bytes,
 				id->buf_type, BuffType[(id->buf_type > 3) ? 0 :  id->buf_type],
 				id->buf_size/2, id->max_multsect);
-	if (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);
@@ -1192,44 +1122,40 @@ static void dump_identity(const struct hd_driveid *id)
 	}
 	puts("");
 
-	if (!(id->field_valid&1))
+	if (!(id->field_valid & 1))
 		printf(" (maybe):");
 
 	printf(" CurCHS=%u/%u/%u, CurSects=%lu, LBA=%s",id->cur_cyls, id->cur_heads,
-													id->cur_sectors,
-													(BB_BIG_ENDIAN) ?
-													(long unsigned int)(id->cur_capacity0 << 16) | id->cur_capacity1 :
-													(long unsigned int)(id->cur_capacity1 << 16) | id->cur_capacity0,
-													((id->capability&2) == 0) ? "no" : "yes");
+		id->cur_sectors,
+		(BB_BIG_ENDIAN) ?
+			(long unsigned int)(id->cur_capacity0 << 16) | id->cur_capacity1 :
+			(long unsigned int)(id->cur_capacity1 << 16) | id->cur_capacity0,
+			((id->capability&2) == 0) ? "no" : "yes");
 
-	if (id->capability&2)
+	if (id->capability & 2)
 		printf(", LBAsects=%u", id->lba_capacity);
 
-	printf("\n IORDY=%s", (id->capability&8) ? (id->capability&4) ?  "on/off" : "yes" : "no");
+	printf("\n IORDY=%s", (id->capability & 8) ? (id->capability & 4) ?  "on/off" : "yes" : "no");
 
-	if (((id->capability&8) || (id->field_valid&2)) && id->field_valid&2)
+	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))
+	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)
-	{
+	if (id->tPIO <= 5) {
 		printf("pio0 ");
 		if (id->tPIO >= 1) printf("pio1 ");
 		if (id->tPIO >= 2) printf("pio2 ");
 	}
-	if (id->field_valid&2)
-	{
+	if (id->field_valid & 2) {
 		if (id->eide_pio_modes & 1) printf("pio3 ");
 		if (id->eide_pio_modes & 2) printf("pio4 ");
 		if (id->eide_pio_modes &~3) printf("pio? ");
 	}
-	if (id->capability&1)
-	{
-		if (id->dma_1word | id->dma_mword)
-		{
+	if (id->capability & 1) {
+		if (id->dma_1word | id->dma_mword) {
 			printf("\n DMA modes:  ");
 			if (id->dma_1word & 0x100) printf("*");
 			if (id->dma_1word & 1) printf("sdma0 ");
@@ -1249,8 +1175,7 @@ static void dump_identity(const struct hd_driveid *id)
 			if (id->dma_mword & 0xf8) printf("mdma? ");
 		}
 	}
-	if (((id->capability&8) || (id->field_valid&2))	&& id->field_valid&4)
-	{
+	if (((id->capability & 8) || (id->field_valid & 2)) && id->field_valid & 4) {
 		printf("\n UDMA modes: ");
 		if (id->dma_ultra & 0x100) printf("*");
 		if (id->dma_ultra & 0x001) printf("udma0 ");
@@ -1259,11 +1184,9 @@ static void dump_identity(const struct hd_driveid *id)
 		if (id->dma_ultra & 0x400) printf("*");
 		if (id->dma_ultra & 0x004) printf("udma2 ");
 #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) printf("*");
 			if (id->dma_ultra & 0x0008) printf("udma3 ");
@@ -1278,20 +1201,20 @@ static void dump_identity(const struct hd_driveid *id)
 		}
 	}
 	printf("\n AdvancedPM=%s",((id_regs[83]&8)==0)?"no":"yes");
-	if (id_regs[83] & 8)
-	{
-		if (!(id_regs[86]&8))
+	if (id_regs[83] & 8) {
+		if (!(id_regs[86] & 8))
 			printf(": disabled (255)");
-		else if ((id_regs[91]&0xFF00)!=0x4000)
+		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)
+	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))
-	{
+	if ((id->minor_rev_num && id->minor_rev_num <= 31)
+	 || (id->major_rev_num && id->minor_rev_num <= 31)
+	) {
 		printf("\n Drive conforms to: %s: ", (id->minor_rev_num <= 31) ? minor_str[id->minor_rev_num] : "Unknown");
 		if (id->major_rev_num != 0x0000 &&  /* NOVAL_0 */
 		    id->major_rev_num != 0xFFFF) {  /* NOVAL_1 */
@@ -1328,7 +1251,8 @@ static int read_big_block(int fd, char *buf)
 {
 	int i;
 
-	if ((i = read(fd, buf, TIMING_BUF_BYTES)) != TIMING_BUF_BYTES) {
+	i = read(fd, buf, TIMING_BUF_BYTES);
+	if (i != TIMING_BUF_BYTES) {
 		bb_error_msg("read(%d bytes) failed (rc=%d)", TIMING_BUF_BYTES, i);
 		return 1;
 	}
@@ -1348,8 +1272,8 @@ static void print_timing(int t, double e)
 
 static int do_blkgetsize (int fd, unsigned long long *blksize64)
 {
-	int		rc;
-	unsigned int	blksize32 = 0;
+	int rc;
+	unsigned blksize32 = 0;
 
 	if (0 == ioctl(fd, BLKGETSIZE64, blksize64)) {	// returns bytes
 		*blksize64 /= 512;
@@ -1389,8 +1313,9 @@ static void do_time(int flag, int fd)
 
 	setitimer(ITIMER_REAL, &(struct itimerval){{1000,0},{1000,0}}, NULL);
 
-	if (flag  == 0) /* Time cache */
-	{
+	if (flag  == 0) {
+		/* Time cache */
+
 		if (seek_to_zero (fd)) return;
 		if (read_big_block (fd, buf)) return;
 		printf(" Timing cached reads:   ");
@@ -1423,9 +1348,9 @@ static void do_time(int flag, int fd)
 		print_timing(BUFCACHE_FACTOR * total_MB, elapsed);
 		flush_buffer_cache(fd);
 		sleep(1);
-	}
-	else /* Time device */
-	{
+	} else {
+		/* Time device */
+
 		printf(" Timing buffered disk reads:  ");
 		fflush(stdout);
 		/*
@@ -1458,7 +1383,7 @@ static void on_off (unsigned int value)
 	printf(value ? " (on)\n" : " (off)\n");
 }
 
-#ifdef CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF
+#if ENABLE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF
 static void bus_state_value(unsigned int value)
 {
 	if (value == BUSSTATE_ON)
@@ -1502,44 +1427,44 @@ static void interpret_standby(unsigned int standby)
 }
 
 struct xfermode_entry {
-    int val;
-    const char *name;
+	int val;
+	const char *name;
 };
 
 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 }
+	{ 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 }
 };
 
 static int translate_xfermode(char * name)
@@ -1548,9 +1473,7 @@ static int translate_xfermode(char * name)
 	char *endptr;
 	int val = -1;
 
-
-	for (tmp = xfermode_table; tmp->name != NULL; ++tmp)
-	{
+	for (tmp = xfermode_table; tmp->name != NULL; ++tmp) {
 		if (!strcmp(name, tmp->name))
 			return tmp->val;
 	}
@@ -1604,21 +1527,18 @@ static void process_dev(char *devname)
 	fd = xopen(devname, O_RDONLY|O_NONBLOCK);
 	printf("\n%s:\n", devname);
 
-	if (set_readahead)
-	{
+	if (set_readahead) {
 		print_flag(get_readahead,"fs readahead", Xreadahead);
 		bb_ioctl(fd, BLKRASET,(int *)Xreadahead,"BLKRASET");
 	}
-#ifdef CONFIG_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF
-	if (unregister_hwif)
-	{
+#if ENABLE_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF
+	if (unregister_hwif) {
 		printf(" attempting to unregister hwif#%lu\n", hwif);
 		bb_ioctl(fd, HDIO_UNREGISTER_HWIF,(int *)(unsigned long)hwif,"HDIO_UNREGISTER_HWIF");
 	}
 #endif
-#ifdef CONFIG_FEATURE_HDPARM_HDIO_SCAN_HWIF
-	if (scan_hwif)
-	{
+#if ENABLE_FEATURE_HDPARM_HDIO_SCAN_HWIF
+	if (scan_hwif) {
 		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;
@@ -1628,10 +1548,8 @@ static void process_dev(char *devname)
 		args[1] = 0;
 	}
 #endif
-	if (set_piomode)
-	{
-		if (noisy_piomode)
-		{
+	if (set_piomode) {
+		if (noisy_piomode) {
 			printf(" attempting to ");
 			if (piomode == 255)
 				printf("auto-tune PIO mode\n");
@@ -1644,13 +1562,11 @@ static void process_dev(char *devname)
 		}
 		bb_ioctl(fd, HDIO_SET_PIO_MODE, (int *)(unsigned long)piomode, "HDIO_SET_PIO_MODE");
 	}
-	if (set_io32bit)
-	{
+	if (set_io32bit) {
 		print_flag(get_io32bit,"32-bit IO_support flag", io32bit);
 		bb_ioctl(fd, HDIO_SET_32BIT, (int *)io32bit, "HDIO_SET_32BIT");
 	}
-	if (set_mult)
-	{
+	if (set_mult) {
 		print_flag(get_mult, "multcount", mult);
 #ifdef HDIO_DRIVE_CMD
 		bb_ioctl(fd, HDIO_SET_MULTCOUNT, &mult, "HDIO_SET_MULTCOUNT");
@@ -1658,70 +1574,59 @@ static void process_dev(char *devname)
 		force_operation |= (!bb_ioctl(fd, HDIO_SET_MULTCOUNT, &mult, "HDIO_SET_MULTCOUNT"));
 #endif
 	}
-	if (set_readonly)
-	{
+	if (set_readonly) {
 		print_flag_on_off(get_readonly,"readonly", readonly);
 		bb_ioctl(fd, BLKROSET, &readonly, "BLKROSET");
 	}
-	if (set_unmask)
-	{
+	if (set_unmask) {
 		print_flag_on_off(get_unmask,"unmaskirq", unmask);
 		bb_ioctl(fd, HDIO_SET_UNMASKINTR, (int *)unmask, "HDIO_SET_UNMASKINTR");
 	}
-#ifdef CONFIG_FEATURE_HDPARM_HDIO_GETSET_DMA
-	if (set_dma)
-	{
+#if ENABLE_FEATURE_HDPARM_HDIO_GETSET_DMA
+	if (set_dma) {
 		print_flag_on_off(get_dma, "using_dma", dma);
 		bb_ioctl(fd, HDIO_SET_DMA, (int *)dma, "HDIO_SET_DMA");
 	}
-#endif /* CONFIG_FEATURE_HDPARM_HDIO_GETSET_DMA */
-	if (set_dma_q)
-	{
+#endif /* FEATURE_HDPARM_HDIO_GETSET_DMA */
+	if (set_dma_q) {
 		print_flag_on_off(get_dma_q,"DMA queue_depth", dma_q);
 		bb_ioctl(fd, HDIO_SET_QDMA, (int *)dma_q, "HDIO_SET_QDMA");
 	}
-	if (set_nowerr)
-	{
+	if (set_nowerr) {
 		print_flag_on_off(get_nowerr,"nowerr", nowerr);
 		bb_ioctl(fd, HDIO_SET_NOWERR, (int *)nowerr,"HDIO_SET_NOWERR");
 	}
-	if (set_keep)
-	{
+	if (set_keep) {
 		print_flag_on_off(get_keep,"keep_settings", keep);
 		bb_ioctl(fd, HDIO_SET_KEEPSETTINGS, (int *)keep,"HDIO_SET_KEEPSETTINGS");
 	}
 #ifdef HDIO_DRIVE_CMD
-	if (set_doorlock)
-	{
+	if (set_doorlock) {
 		args[0] = doorlock ? WIN_DOORLOCK : WIN_DOORUNLOCK;
 		args[2] = 0;
 		print_flag_on_off(get_doorlock,"drive doorlock", doorlock);
 		bb_ioctl(fd, HDIO_DRIVE_CMD, &args,"HDIO_DRIVE_CMD(doorlock)");
 		args[0] = WIN_SETFEATURES;
 	}
-	if (set_dkeep)
-	{
+	if (set_dkeep) {
 		/* lock/unlock the drive's "feature" settings */
 		print_flag_on_off(get_dkeep,"drive keep features", dkeep);
 		args[2] = dkeep ? 0x66 : 0xcc;
 		bb_ioctl(fd, HDIO_DRIVE_CMD, &args,"HDIO_DRIVE_CMD(keepsettings)");
 	}
-	if (set_defects)
-	{
+	if (set_defects) {
 		args[2] = defects ? 0x04 : 0x84;
 		print_flag(get_defects,"drive defect-mgmt", defects);
 		bb_ioctl(fd, HDIO_DRIVE_CMD, &args,"HDIO_DRIVE_CMD(defectmgmt)");
 	}
-	if (set_prefetch)
-	{
+	if (set_prefetch) {
 		args[1] = prefetch;
 		args[2] = 0xab;
 		print_flag(get_prefetch,"drive prefetch", prefetch);
 		bb_ioctl(fd, HDIO_DRIVE_CMD, &args, "HDIO_DRIVE_CMD(setprefetch)");
 		args[1] = 0;
 	}
-	if (set_xfermode)
-	{
+	if (set_xfermode) {
 		args[1] = xfermode_requested;
 		args[2] = 3;
 		if (get_xfermode)
@@ -1732,14 +1637,12 @@ static void process_dev(char *devname)
 		bb_ioctl(fd, HDIO_DRIVE_CMD, &args,"HDIO_DRIVE_CMD(setxfermode)");
 		args[1] = 0;
 	}
-	if (set_lookahead)
-	{
+	if (set_lookahead) {
 		args[2] = lookahead ? 0xaa : 0x55;
 		print_flag_on_off(get_lookahead,"drive read-lookahead", lookahead);
 		bb_ioctl(fd, HDIO_DRIVE_CMD, &args, "HDIO_DRIVE_CMD(setreadahead)");
 	}
-	if (set_apmmode)
-	{
+	if (set_apmmode) {
 		args[2] = (apmmode == 255) ? 0x85 /* disable */ : 0x05 /* set */; /* feature register */
 		args[1] = apmmode; /* sector count register 1-255 */
 		if (get_apmmode)
@@ -1747,8 +1650,7 @@ static void process_dev(char *devname)
 		bb_ioctl(fd, HDIO_DRIVE_CMD, &args,"HDIO_DRIVE_CMD");
 		args[1] = 0;
 	}
-	if (set_wcache)
-	{
+	if (set_wcache)	{
 #ifdef DO_FLUSHCACHE
 #ifndef WIN_FLUSHCACHE
 #define WIN_FLUSHCACHE 0xe7
@@ -1772,8 +1674,7 @@ static void process_dev(char *devname)
 	   is preserved, including args[2] */
 	args[2] = 0;
 
-	if (set_standbynow)
-	{
+	if (set_standbynow) {
 #ifndef WIN_STANDBYNOW1
 #define WIN_STANDBYNOW1 0xE0
 #endif
@@ -1784,8 +1685,7 @@ static void process_dev(char *devname)
 		args[0] = WIN_STANDBYNOW1;
 		bb_ioctl_alt(fd, HDIO_DRIVE_CMD, args, WIN_STANDBYNOW2, "HDIO_DRIVE_CMD(standby)");
 	}
-	if (set_sleepnow)
-	{
+	if (set_sleepnow) {
 #ifndef WIN_SLEEPNOW1
 #define WIN_SLEEPNOW1 0xE6
 #endif
@@ -1796,18 +1696,15 @@ static void process_dev(char *devname)
 		args[0] = WIN_SLEEPNOW1;
 		bb_ioctl_alt(fd, HDIO_DRIVE_CMD, args, WIN_SLEEPNOW2, "HDIO_DRIVE_CMD(sleep)");
 	}
-	if (set_seagate)
-	{
+	if (set_seagate) {
 		args[0] = 0xfb;
 		if (get_seagate) printf(" disabling Seagate auto powersaving mode\n");
 		bb_ioctl(fd, HDIO_DRIVE_CMD, &args, "HDIO_DRIVE_CMD(seagatepwrsave)");
 	}
-	if (set_standby)
-	{
+	if (set_standby) {
 		args[0] = WIN_SETIDLE1;
 		args[1] = standby_requested;
-		if (get_standby)
-		{
+		if (get_standby) {
 			print_flag(1,"standby", standby_requested);
 			interpret_standby(standby_requested);
 		}
@@ -1815,8 +1712,7 @@ static void process_dev(char *devname)
 		args[1] = 0;
 	}
 #else	/* HDIO_DRIVE_CMD */
-	if (force_operation)
-	{
+	if (force_operation) {
 		char buf[512];
 		flush_buffer_cache(fd);
 		if (-1 == read(fd, buf, sizeof(buf)))
@@ -1824,24 +1720,18 @@ static void process_dev(char *devname)
 	}
 #endif	/* HDIO_DRIVE_CMD */
 
-	if (get_mult || get_identity)
-	{
+	if (get_mult || get_identity) {
 		multcount = -1;
-		if (ioctl(fd, HDIO_GET_MULTCOUNT, &multcount))
-		{
+		if (ioctl(fd, HDIO_GET_MULTCOUNT, &multcount)) {
 			if (get_mult)
 				bb_perror_msg("HDIO_GET_MULTCOUNT");
-		}
-		else if (get_mult)
-		{
+		} else if (get_mult) {
 			printf(fmt, "multcount", multcount);
 			on_off(multcount);
 		}
 	}
-	if (get_io32bit)
-	{
-		if (!bb_ioctl(fd, HDIO_GET_32BIT, &parm, "HDIO_GET_32BIT"))
-		{
+	if (get_io32bit) {
+		if (!bb_ioctl(fd, HDIO_GET_32BIT, &parm, "HDIO_GET_32BIT")) {
 			printf(" IO_support\t=%3ld (", parm);
 			if (parm == 0)
 				printf("default 16-bit)\n");
@@ -1857,14 +1747,13 @@ static void process_dev(char *devname)
 				printf("\?\?\?)\n");
 		}
 	}
-	if (get_unmask)
-	{
+	if (get_unmask) {
 		bb_ioctl_on_off(fd, HDIO_GET_UNMASKINTR,(unsigned long *)parm,
 						"HDIO_GET_UNMASKINTR","unmaskirq");
 	}
 
 
-#ifdef CONFIG_FEATURE_HDPARM_HDIO_GETSET_DMA
+#if ENABLE_FEATURE_HDPARM_HDIO_GETSET_DMA
 	if (get_dma) {
 		if (!bb_ioctl(fd, HDIO_GET_DMA, &parm, "HDIO_GET_DMA"))
 		{
@@ -1876,36 +1765,29 @@ static void process_dev(char *devname)
 		}
 	}
 #endif
-	if (get_dma_q)
-	{
+	if (get_dma_q) {
 		bb_ioctl_on_off (fd, HDIO_GET_QDMA,(unsigned long *)parm,
 						  "HDIO_GET_QDMA","queue_depth");
 	}
-	if (get_keep)
-	{
+	if (get_keep) {
 		bb_ioctl_on_off (fd, HDIO_GET_KEEPSETTINGS,(unsigned long *)parm,
 							"HDIO_GET_KEEPSETTINGS","keepsettings");
 	}
 
-	if (get_nowerr)
-	{
+	if (get_nowerr) {
 		bb_ioctl_on_off  (fd, HDIO_GET_NOWERR,(unsigned long *)&parm,
 							"HDIO_GET_NOWERR","nowerr");
 	}
-	if (get_readonly)
-	{
+	if (get_readonly) {
 		bb_ioctl_on_off(fd, BLKROGET,(unsigned long *)parm,
 						  "BLKROGET","readonly");
 	}
-	if (get_readahead)
-	{
+	if (get_readahead) {
 		bb_ioctl_on_off (fd, BLKRAGET, (unsigned long *) parm,
 							"BLKRAGET","readahead");
 	}
-	if (get_geom)
-	{
-		if (!bb_ioctl(fd, BLKGETSIZE, &parm, "BLKGETSIZE"))
-		{
+	if (get_geom) {
+		if (!bb_ioctl(fd, BLKGETSIZE, &parm, "BLKGETSIZE")) {
 			struct hd_geometry g;
 
 			if (!bb_ioctl(fd, HDIO_GETGEO, &g, "HDIO_GETGEO"))
@@ -1914,8 +1796,7 @@ static void process_dev(char *devname)
 		}
 	}
 #ifdef HDIO_DRIVE_CMD
-	if (get_powermode)
-	{
+	if (get_powermode) {
 #ifndef WIN_CHECKPOWERMODE1
 #define WIN_CHECKPOWERMODE1 0xE5
 #endif
@@ -1925,58 +1806,48 @@ static void process_dev(char *devname)
 		const char *state;
 
 		args[0] = WIN_CHECKPOWERMODE1;
-		if (bb_ioctl_alt(fd, HDIO_DRIVE_CMD, args, WIN_CHECKPOWERMODE2, 0))
-		{
+		if (bb_ioctl_alt(fd, HDIO_DRIVE_CMD, args, WIN_CHECKPOWERMODE2, 0)) {
 			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 (perform_reset)
-	{
+#if ENABLE_FEATURE_HDPARM_HDIO_DRIVE_RESET
+	if (perform_reset) {
 		bb_ioctl(fd, HDIO_DRIVE_RESET, NULL, "HDIO_DRIVE_RESET");
 	}
-#endif /* CONFIG_FEATURE_HDPARM_HDIO_DRIVE_RESET */
-#ifdef CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF
-	if (perform_tristate)
-	{
+#endif /* FEATURE_HDPARM_HDIO_DRIVE_RESET */
+#if ENABLE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF
+	if (perform_tristate) {
 		args[0] = 0;
 		args[1] = tristate;
 		bb_ioctl(fd, HDIO_TRISTATE_HWIF, &args, "HDIO_TRISTATE_HWIF");
 	}
-#endif /* CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF */
-#ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY
-	if (get_identity)
-	{
+#endif /* FEATURE_HDPARM_HDIO_TRISTATE_HWIF */
+#if ENABLE_FEATURE_HDPARM_GET_IDENTITY
+	if (get_identity) {
 		static struct hd_driveid id;
 
-		if (!ioctl(fd, HDIO_GET_IDENTITY, &id))
-		{
-			if (multcount != -1)
-			{
+		if (!ioctl(fd, HDIO_GET_IDENTITY, &id))	{
+			if (multcount != -1) {
 				id.multsect = multcount;
 				id.multsect_valid |= 1;
-			}
-			else
+			} else
 				id.multsect_valid &= ~1;
 			dump_identity(&id);
-		}
-		else if (errno == -ENOMSG)
+		} else if (errno == -ENOMSG)
 			printf(" no identification info available\n");
 		else
 			bb_perror_msg("HDIO_GET_IDENTITY");
 	}
 
-	if (get_IDentity)
-	{
+	if (get_IDentity) {
 		unsigned char args1[4+512]; /* = { ... } will eat 0.5k of rodata! */
 
 		memset(args1, 0, sizeof(args1));
@@ -1986,20 +1857,16 @@ static void process_dev(char *devname)
 			identify((void *)(args1 + 4));
 	}
 #endif
-#ifdef CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF
-	if (set_busstate)
-	{
-		if (get_busstate)
-		{
+#if ENABLE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF
+	if (set_busstate) {
+		if (get_busstate) {
 			print_flag(1, "bus state", busstate);
 			bus_state_value(busstate);
 		}
 		bb_ioctl(fd, HDIO_SET_BUSSTATE, (int *)(unsigned long)busstate, "HDIO_SET_BUSSTATE");
 	}
-	if (get_busstate)
-	{
-		if (!bb_ioctl(fd, HDIO_GET_BUSSTATE, &parm, "HDIO_GET_BUSSTATE"))
-		{
+	if (get_busstate) {
+		if (!bb_ioctl(fd, HDIO_GET_BUSSTATE, &parm, "HDIO_GET_BUSSTATE")) {
 			printf(fmt, "bus state", parm);
 			bus_state_value(parm);
 		}
@@ -2008,17 +1875,16 @@ static void process_dev(char *devname)
 	if (reread_partn)
 		bb_ioctl(fd, BLKRRPART, NULL, "BLKRRPART");
 
-
 	if (do_ctimings)
-		do_time(0,fd);		/*time cache  */
+		do_time(0, fd); /* time cache */
 	if (do_timings)
-		do_time(1,fd);		/*time device */
+		do_time(1, fd); /* time device */
 	if (do_flush)
 		flush_buffer_cache(fd);
 	close(fd);
 }
 
-#ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY
+#if ENABLE_FEATURE_HDPARM_GET_IDENTITY
 static int fromhex(unsigned char c)
 {
 	if (isdigit(c))
@@ -2039,7 +1905,7 @@ static void identify_from_stdin(void)
 
 	// Convert the newline-separated hex data into an identify block.
 
-	for (i = 0; i<256; i++)  {
+	for (i = 0; i < 256; i++) {
 		int j;
 		for (j = 0; j < 4; j++)
 			sbuf[i] = (sbuf[i] << 4) + fromhex(*(b++));