OpenE2K
/
linux
6
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

libata: Use 'bool' return value for ata_id_XXX 

Most ata_id_XXX inlines are simple tests, so we should set
the return value to 'bool' here.

Signed-off-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Jeff Garzik <jgarzik@pobox.com>
This commit is contained in:
Hannes Reinecke 2011-03-14 08:54:20 +01:00 committed by Jeff Garzik
parent 578ca87c9d
commit 4dce8ba94c
1 changed files with 75 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

156
include/linux/ata.h
View File

@ -600,42 +600,42 @@ static inline bool ata_id_has_dipm(const u16 *id)
} }
static inline int ata_id_has_fua(const u16 *id) static inline bool ata_id_has_fua(const u16 *id)
{ {
if ((id[ATA_ID_CFSSE] & 0xC000) != 0x4000) if ((id[ATA_ID_CFSSE] & 0xC000) != 0x4000)
return 0; return false;
return id[ATA_ID_CFSSE] & (1 << 6); return id[ATA_ID_CFSSE] & (1 << 6);
} }
static inline int ata_id_has_flush(const u16 *id) static inline bool ata_id_has_flush(const u16 *id)
{ {
if ((id[ATA_ID_COMMAND_SET_2] & 0xC000) != 0x4000) if ((id[ATA_ID_COMMAND_SET_2] & 0xC000) != 0x4000)
return 0; return false;
return id[ATA_ID_COMMAND_SET_2] & (1 << 12); return id[ATA_ID_COMMAND_SET_2] & (1 << 12);
} }
static inline int ata_id_flush_enabled(const u16 *id) static inline bool ata_id_flush_enabled(const u16 *id)
{ {
if (ata_id_has_flush(id) == 0) if (ata_id_has_flush(id) == 0)
return 0; return false;
if ((id[ATA_ID_CSF_DEFAULT] & 0xC000) != 0x4000) if ((id[ATA_ID_CSF_DEFAULT] & 0xC000) != 0x4000)
return 0; return false;
return id[ATA_ID_CFS_ENABLE_2] & (1 << 12); return id[ATA_ID_CFS_ENABLE_2] & (1 << 12);
} }
static inline int ata_id_has_flush_ext(const u16 *id) static inline bool ata_id_has_flush_ext(const u16 *id)
{ {
if ((id[ATA_ID_COMMAND_SET_2] & 0xC000) != 0x4000) if ((id[ATA_ID_COMMAND_SET_2] & 0xC000) != 0x4000)
return 0; return false;
return id[ATA_ID_COMMAND_SET_2] & (1 << 13); return id[ATA_ID_COMMAND_SET_2] & (1 << 13);
} }
static inline int ata_id_flush_ext_enabled(const u16 *id) static inline bool ata_id_flush_ext_enabled(const u16 *id)
{ {
if (ata_id_has_flush_ext(id) == 0) if (ata_id_has_flush_ext(id) == 0)
return 0; return false;
if ((id[ATA_ID_CSF_DEFAULT] & 0xC000) != 0x4000) if ((id[ATA_ID_CSF_DEFAULT] & 0xC000) != 0x4000)
return 0; return false;
/* /*
* some Maxtor disks have bit 13 defined incorrectly * some Maxtor disks have bit 13 defined incorrectly
* so check bit 10 too * so check bit 10 too
@ -688,64 +688,64 @@ static inline u16 ata_id_logical_sector_offset(const u16 *id,
return 0; return 0;
} }
static inline int ata_id_has_lba48(const u16 *id) static inline bool ata_id_has_lba48(const u16 *id)
{ {
if ((id[ATA_ID_COMMAND_SET_2] & 0xC000) != 0x4000) if ((id[ATA_ID_COMMAND_SET_2] & 0xC000) != 0x4000)
return 0; return false;
if (!ata_id_u64(id, ATA_ID_LBA_CAPACITY_2)) if (!ata_id_u64(id, ATA_ID_LBA_CAPACITY_2))
return 0; return false;
return id[ATA_ID_COMMAND_SET_2] & (1 << 10); return id[ATA_ID_COMMAND_SET_2] & (1 << 10);
} }
static inline int ata_id_lba48_enabled(const u16 *id) static inline bool ata_id_lba48_enabled(const u16 *id)
{ {
if (ata_id_has_lba48(id) == 0) if (ata_id_has_lba48(id) == 0)
return 0; return false;
if ((id[ATA_ID_CSF_DEFAULT] & 0xC000) != 0x4000) if ((id[ATA_ID_CSF_DEFAULT] & 0xC000) != 0x4000)
return 0; return false;
return id[ATA_ID_CFS_ENABLE_2] & (1 << 10); return id[ATA_ID_CFS_ENABLE_2] & (1 << 10);
} }
static inline int ata_id_hpa_enabled(const u16 *id) static inline bool ata_id_hpa_enabled(const u16 *id)
{ {
/* Yes children, word 83 valid bits cover word 82 data */ /* Yes children, word 83 valid bits cover word 82 data */
if ((id[ATA_ID_COMMAND_SET_2] & 0xC000) != 0x4000) if ((id[ATA_ID_COMMAND_SET_2] & 0xC000) != 0x4000)
return 0; return false;
/* And 87 covers 85-87 */ /* And 87 covers 85-87 */
if ((id[ATA_ID_CSF_DEFAULT] & 0xC000) != 0x4000) if ((id[ATA_ID_CSF_DEFAULT] & 0xC000) != 0x4000)
return 0; return false;
/* Check command sets enabled as well as supported */ /* Check command sets enabled as well as supported */
if ((id[ATA_ID_CFS_ENABLE_1] & (1 << 10)) == 0) if ((id[ATA_ID_CFS_ENABLE_1] & (1 << 10)) == 0)
return 0; return false;
return id[ATA_ID_COMMAND_SET_1] & (1 << 10); return id[ATA_ID_COMMAND_SET_1] & (1 << 10);
} }
static inline int ata_id_has_wcache(const u16 *id) static inline bool ata_id_has_wcache(const u16 *id)
{ {
/* Yes children, word 83 valid bits cover word 82 data */ /* Yes children, word 83 valid bits cover word 82 data */
if ((id[ATA_ID_COMMAND_SET_2] & 0xC000) != 0x4000) if ((id[ATA_ID_COMMAND_SET_2] & 0xC000) != 0x4000)
return 0; return false;
return id[ATA_ID_COMMAND_SET_1] & (1 << 5); return id[ATA_ID_COMMAND_SET_1] & (1 << 5);
} }
static inline int ata_id_has_pm(const u16 *id) static inline bool ata_id_has_pm(const u16 *id)
{ {
if ((id[ATA_ID_COMMAND_SET_2] & 0xC000) != 0x4000) if ((id[ATA_ID_COMMAND_SET_2] & 0xC000) != 0x4000)
return 0; return false;
return id[ATA_ID_COMMAND_SET_1] & (1 << 3); return id[ATA_ID_COMMAND_SET_1] & (1 << 3);
} }
static inline int ata_id_rahead_enabled(const u16 *id) static inline bool ata_id_rahead_enabled(const u16 *id)
{ {
if ((id[ATA_ID_CSF_DEFAULT] & 0xC000) != 0x4000) if ((id[ATA_ID_CSF_DEFAULT] & 0xC000) != 0x4000)
return 0; return false;
return id[ATA_ID_CFS_ENABLE_1] & (1 << 6); return id[ATA_ID_CFS_ENABLE_1] & (1 << 6);
} }
static inline int ata_id_wcache_enabled(const u16 *id) static inline bool ata_id_wcache_enabled(const u16 *id)
{ {
if ((id[ATA_ID_CSF_DEFAULT] & 0xC000) != 0x4000) if ((id[ATA_ID_CSF_DEFAULT] & 0xC000) != 0x4000)
return 0; return false;
return id[ATA_ID_CFS_ENABLE_1] & (1 << 5); return id[ATA_ID_CFS_ENABLE_1] & (1 << 5);
} }
@ -775,7 +775,7 @@ static inline unsigned int ata_id_major_version(const u16 *id)
return mver; return mver;
} }
static inline int ata_id_is_sata(const u16 *id) static inline bool ata_id_is_sata(const u16 *id)
{ {
/* /*
* See if word 93 is 0 AND drive is at least ATA-5 compatible * See if word 93 is 0 AND drive is at least ATA-5 compatible
@ -784,37 +784,35 @@ static inline int ata_id_is_sata(const u16 *id)
* 0x0000 and 0xffff along with the earlier ATA revisions... * 0x0000 and 0xffff along with the earlier ATA revisions...
*/ */
if (id[ATA_ID_HW_CONFIG] == 0 && (short)id[ATA_ID_MAJOR_VER] >= 0x0020) if (id[ATA_ID_HW_CONFIG] == 0 && (short)id[ATA_ID_MAJOR_VER] >= 0x0020)
return 1; return true;
return 0; return false;
} }
static inline int ata_id_has_tpm(const u16 *id) static inline bool ata_id_has_tpm(const u16 *id)
{ {
/* The TPM bits are only valid on ATA8 */ /* The TPM bits are only valid on ATA8 */
if (ata_id_major_version(id) < 8) if (ata_id_major_version(id) < 8)
return 0; return false;
if ((id[48] & 0xC000) != 0x4000) if ((id[48] & 0xC000) != 0x4000)
return 0; return false;
return id[48] & (1 << 0); return id[48] & (1 << 0);
} }
static inline int ata_id_has_dword_io(const u16 *id) static inline bool ata_id_has_dword_io(const u16 *id)
{ {
/* ATA 8 reuses this flag for "trusted" computing */ /* ATA 8 reuses this flag for "trusted" computing */
if (ata_id_major_version(id) > 7) if (ata_id_major_version(id) > 7)
return 0; return false;
if (id[ATA_ID_DWORD_IO] & (1 << 0)) return id[ATA_ID_DWORD_IO] & (1 << 0);
return 1;
return 0;
} }
static inline int ata_id_has_unload(const u16 *id) static inline bool ata_id_has_unload(const u16 *id)
{ {
if (ata_id_major_version(id) >= 7 && if (ata_id_major_version(id) >= 7 &&
(id[ATA_ID_CFSSE] & 0xC000) == 0x4000 && (id[ATA_ID_CFSSE] & 0xC000) == 0x4000 &&
id[ATA_ID_CFSSE] & (1 << 13)) id[ATA_ID_CFSSE] & (1 << 13))
return 1; return true;
return 0; return false;
} }
static inline bool ata_id_has_wwn(const u16 *id) static inline bool ata_id_has_wwn(const u16 *id)
@ -850,25 +848,25 @@ static inline int ata_id_rotation_rate(const u16 *id)
return val; return val;
} }
static inline int ata_id_has_trim(const u16 *id) static inline bool ata_id_has_trim(const u16 *id)
{ {
if (ata_id_major_version(id) >= 7 && if (ata_id_major_version(id) >= 7 &&
(id[ATA_ID_DATA_SET_MGMT] & 1)) (id[ATA_ID_DATA_SET_MGMT] & 1))
return 1; return true;
return 0; return false;
} }
static inline int ata_id_has_zero_after_trim(const u16 *id) static inline bool ata_id_has_zero_after_trim(const u16 *id)
{ {
/* DSM supported, deterministic read, and read zero after trim set */ /* DSM supported, deterministic read, and read zero after trim set */
if (ata_id_has_trim(id) && if (ata_id_has_trim(id) &&
(id[ATA_ID_ADDITIONAL_SUPP] & 0x4020) == 0x4020) (id[ATA_ID_ADDITIONAL_SUPP] & 0x4020) == 0x4020)
return 1; return true;
return 0; return false;
} }
static inline int ata_id_current_chs_valid(const u16 *id) static inline bool ata_id_current_chs_valid(const u16 *id)
{ {
/* For ATA-1 devices, if the INITIALIZE DEVICE PARAMETERS command /* For ATA-1 devices, if the INITIALIZE DEVICE PARAMETERS command
has not been issued to the device then the values of has not been issued to the device then the values of
@ -880,11 +878,11 @@ static inline int ata_id_current_chs_valid(const u16 *id)
id[ATA_ID_CUR_SECTORS]; /* sectors in current translation */ id[ATA_ID_CUR_SECTORS]; /* sectors in current translation */
} }
static inline int ata_id_is_cfa(const u16 *id) static inline bool ata_id_is_cfa(const u16 *id)
{ {
if ((id[ATA_ID_CONFIG] == 0x848A) || /* Traditional CF */ if ((id[ATA_ID_CONFIG] == 0x848A) || /* Traditional CF */
(id[ATA_ID_CONFIG] == 0x844A)) /* Delkin Devices CF */ (id[ATA_ID_CONFIG] == 0x844A)) /* Delkin Devices CF */
return 1; return true;
/* /*
* CF specs don't require specific value in the word 0 anymore and yet * CF specs don't require specific value in the word 0 anymore and yet
* they forbid to report the ATA version in the word 80 and require the * they forbid to report the ATA version in the word 80 and require the
@ -893,44 +891,40 @@ static inline int ata_id_is_cfa(const u16 *id)
* and while those that don't indicate CFA feature support need some * and while those that don't indicate CFA feature support need some
* sort of quirk list, it seems impractical for the ones that do... * sort of quirk list, it seems impractical for the ones that do...
*/ */
if ((id[ATA_ID_COMMAND_SET_2] & 0xC004) == 0x4004) return (id[ATA_ID_COMMAND_SET_2] & 0xC004) == 0x4004;
return 1;
return 0;
} }
static inline int ata_id_is_ssd(const u16 *id) static inline bool ata_id_is_ssd(const u16 *id)
{ {
return id[ATA_ID_ROT_SPEED] == 0x01; return id[ATA_ID_ROT_SPEED] == 0x01;
} }
static inline int ata_id_pio_need_iordy(const u16 *id, const u8 pio) static inline bool ata_id_pio_need_iordy(const u16 *id, const u8 pio)
{ {
/* CF spec. r4.1 Table 22 says no IORDY on PIO5 and PIO6. */ /* CF spec. r4.1 Table 22 says no IORDY on PIO5 and PIO6. */
if (pio > 4 && ata_id_is_cfa(id)) if (pio > 4 && ata_id_is_cfa(id))
return 0; return false;
/* For PIO3 and higher it is mandatory. */ /* For PIO3 and higher it is mandatory. */
if (pio > 2) if (pio > 2)
return 1; return true;
/* Turn it on when possible. */ /* Turn it on when possible. */
if (ata_id_has_iordy(id)) return ata_id_has_iordy(id);
return 1;
return 0;
} }
static inline int ata_drive_40wire(const u16 *dev_id) static inline bool ata_drive_40wire(const u16 *dev_id)
{ {
if (ata_id_is_sata(dev_id)) if (ata_id_is_sata(dev_id))
return 0; /* SATA */ return false; /* SATA */
if ((dev_id[ATA_ID_HW_CONFIG] & 0xE000) == 0x6000) if ((dev_id[ATA_ID_HW_CONFIG] & 0xE000) == 0x6000)
return 0; /* 80 wire */ return false; /* 80 wire */
return 1; return true;
} }
static inline int ata_drive_40wire_relaxed(const u16 *dev_id) static inline bool ata_drive_40wire_relaxed(const u16 *dev_id)
{ {
if ((dev_id[ATA_ID_HW_CONFIG] & 0x2000) == 0x2000) if ((dev_id[ATA_ID_HW_CONFIG] & 0x2000) == 0x2000)
return 0; /* 80 wire */ return false; /* 80 wire */
return 1; return true;
} }
static inline int atapi_cdb_len(const u16 *dev_id) static inline int atapi_cdb_len(const u16 *dev_id)
@ -943,12 +937,12 @@ static inline int atapi_cdb_len(const u16 *dev_id)
} }
} }
static inline int atapi_command_packet_set(const u16 *dev_id) static inline bool atapi_command_packet_set(const u16 *dev_id)
{ {
return (dev_id[ATA_ID_CONFIG] >> 8) & 0x1f; return (dev_id[ATA_ID_CONFIG] >> 8) & 0x1f;
} }
static inline int atapi_id_dmadir(const u16 *dev_id) static inline bool atapi_id_dmadir(const u16 *dev_id)
{ {
return ata_id_major_version(dev_id) >= 7 && (dev_id[62] & 0x8000); return ata_id_major_version(dev_id) >= 7 && (dev_id[62] & 0x8000);
} }
@ -961,13 +955,13 @@ static inline int atapi_id_dmadir(const u16 *dev_id)
* *
* It is called only once for each device. * It is called only once for each device.
*/ */
static inline int ata_id_is_lba_capacity_ok(u16 *id) static inline bool ata_id_is_lba_capacity_ok(u16 *id)
{ {
unsigned long lba_sects, chs_sects, head, tail; unsigned long lba_sects, chs_sects, head, tail;
/* No non-LBA info .. so valid! */ /* No non-LBA info .. so valid! */
if (id[ATA_ID_CYLS] == 0) if (id[ATA_ID_CYLS] == 0)
return 1; return true;
lba_sects = ata_id_u32(id, ATA_ID_LBA_CAPACITY); lba_sects = ata_id_u32(id, ATA_ID_LBA_CAPACITY);
@ -982,13 +976,13 @@ static inline int ata_id_is_lba_capacity_ok(u16 *id)
id[ATA_ID_SECTORS] == 63 && id[ATA_ID_SECTORS] == 63 &&
(id[ATA_ID_HEADS] == 15 || id[ATA_ID_HEADS] == 16) && (id[ATA_ID_HEADS] == 15 || id[ATA_ID_HEADS] == 16) &&
(lba_sects >= 16383 * 63 * id[ATA_ID_HEADS])) (lba_sects >= 16383 * 63 * id[ATA_ID_HEADS]))
return 1; return true;
chs_sects = id[ATA_ID_CYLS] * id[ATA_ID_HEADS] * id[ATA_ID_SECTORS]; chs_sects = id[ATA_ID_CYLS] * id[ATA_ID_HEADS] * id[ATA_ID_SECTORS];
/* perform a rough sanity check on lba_sects: within 10% is OK */ /* perform a rough sanity check on lba_sects: within 10% is OK */
if (lba_sects - chs_sects < chs_sects/10) if (lba_sects - chs_sects < chs_sects/10)
return 1; return true;
/* some drives have the word order reversed */ /* some drives have the word order reversed */
head = (lba_sects >> 16) & 0xffff; head = (lba_sects >> 16) & 0xffff;
@ -997,10 +991,10 @@ static inline int ata_id_is_lba_capacity_ok(u16 *id)
if (lba_sects - chs_sects < chs_sects/10) { if (lba_sects - chs_sects < chs_sects/10) {
*(__le32 *)&id[ATA_ID_LBA_CAPACITY] = __cpu_to_le32(lba_sects); *(__le32 *)&id[ATA_ID_LBA_CAPACITY] = __cpu_to_le32(lba_sects);
return 1; /* LBA capacity is (now) good */ return true; /* LBA capacity is (now) good */
} }
return 0; /* LBA capacity value may be bad */ return false; /* LBA capacity value may be bad */
} }
static inline void ata_id_to_hd_driveid(u16 *id) static inline void ata_id_to_hd_driveid(u16 *id)
@ -1058,19 +1052,19 @@ static inline int is_multi_taskfile(struct ata_taskfile *tf)
(tf->command == ATA_CMD_WRITE_MULTI_FUA_EXT); (tf->command == ATA_CMD_WRITE_MULTI_FUA_EXT);
} }
static inline int ata_ok(u8 status) static inline bool ata_ok(u8 status)
{ {
return ((status & (ATA_BUSY | ATA_DRDY | ATA_DF | ATA_DRQ | ATA_ERR)) return ((status & (ATA_BUSY | ATA_DRDY | ATA_DF | ATA_DRQ | ATA_ERR))
== ATA_DRDY); == ATA_DRDY);
} }
static inline int lba_28_ok(u64 block, u32 n_block) static inline bool lba_28_ok(u64 block, u32 n_block)
{ {
/* check the ending block number: must be LESS THAN 0x0fffffff */ /* check the ending block number: must be LESS THAN 0x0fffffff */
return ((block + n_block) < ((1 << 28) - 1)) && (n_block <= 256); return ((block + n_block) < ((1 << 28) - 1)) && (n_block <= 256);
} }
static inline int lba_48_ok(u64 block, u32 n_block) static inline bool lba_48_ok(u64 block, u32 n_block)
{ {
/* check the ending block number */ /* check the ending block number */
return ((block + n_block - 1) < ((u64)1 << 48)) && (n_block <= 65536); return ((block + n_block - 1) < ((u64)1 << 48)) && (n_block <= 65536);