From: Matthew Wilcox <wil...@linux.intel.com>

ATA 8 permits devices that have sector sizes larger than 512 bytes. We support this by recording the sector size in the ata_device and use it instead of the ATA_SECT_SIZE when the data transfer is a multiple of sectors. Drivers must indicate their support for sector sizes other than 512 by implementing the 'sector_size_supported' port operation.

Signed-off-by: Matthew Wilcox <wil...@linux.intel.com>

--- drivers/ata/Makefile | 11 ++++ drivers/ata/ata-commands.c | 132 ++++++++++++++++++++++++++++++++++++++++++++ drivers/ata/bitops.c | 77 +++++++++++++++++++++++++ drivers/ata/bitops.h | 12 ++++ drivers/ata/libata-core.c | 67 ++++++++++++++++++++++ drivers/ata/libata-scsi.c | 52 +++++++++++++----- include/linux/libata.h | 3 + 7 files changed, 340 insertions(+), 14 deletions(-) create mode 100644 drivers/ata/ata-commands.c create mode 100644 drivers/ata/bitops.c create mode 100644 drivers/ata/bitops.h

diff --git a/drivers/ata/Makefile b/drivers/ata/Makefile index 7f1ecf9..a67d5dc 100644 --- a/drivers/ata/Makefile +++ b/drivers/ata/Makefile @@ -84,3 +84,14 @@ libata-objs := libata-core.o libata-scsi.o libata-eh.o libata-$(CONFIG_ATA_SFF) += libata-sff.o libata-$(CONFIG_SATA_PMP) += libata-pmp.o libata-$(CONFIG_ATA_ACPI) += libata-acpi.o + +hostprogs-y := ata-commands +ata-commands-objs := ata-commands.o bitops.o +HOSTCFLAGS_ata-commands.o := -Iinclude +clean-files := all-commands sector-commands +quiet_cmd_ata-cmds = ATA-CMD + cmd_ata-cmds = $(obj)/ata-commands || (rm -f all-commands
sector-commands) + +$(obj)/all-commands: $(obj)/ata-commands + $(call if_changed,ata-cmds) +$(obj)/libata-core.o: $(obj)/all-commands diff --git a/drivers/ata/ata-commands.c b/drivers/ata/ata-commands.c new file mode 100644 index 0000000..afb40c1 --- /dev/null +++ b/drivers/ata/ata-commands.c @@ -0,0 +1,132 @@ +/* + * ata-commands.c + * + * Copyright (c) 2008 Intel Corporation + * Author: Matthew Wilcox <wil...@linux.intel.com> + * + * This file is part of the Linux kernel, and is made available under + * the terms of the GNU General Public License, version 2 + */ + +#include <stdio.h> + +#include "bitops.h" + +/* We have to define some types to include ata.h */ + +typedef unsigned char u8; +typedef unsigned short u16; +typedef unsigned int u32; +typedef unsigned long long u64; +typedef int bool; +#define false 0 +#define true 1 +#define _LINUX_SWAB_H +#include "linux/ata.h" + +void set_sector_bits(void) +{ + set_bit(ATA_CMD_CFA_TRANSLATE_SECTOR); + set_bit(ATA_CMD_CFA_WRITE_MULTI_WITHOUT_ERASE); + set_bit(ATA_CMD_CFA_WRITE_SECTORS_WITHOUT_ERASE); + set_bit(ATA_CMD_READ); + set_bit(ATA_CMD_READ_EXT); + set_bit(ATA_CMD_READ_QUEUED); + set_bit(ATA_CMD_READ_QUEUED_EXT); + set_bit(ATA_CMD_FPDMA_READ); + set_bit(ATA_CMD_READ_MULTI); + set_bit(ATA_CMD_READ_MULTI_EXT); + set_bit(ATA_CMD_PIO_READ); + set_bit(ATA_CMD_PIO_READ_EXT); + set_bit(ATA_CMD_READ_STREAM_DMA_EXT); + set_bit(ATA_CMD_READ_STREAM_EXT); + set_bit(ATA_CMD_VERIFY); + set_bit(ATA_CMD_VERIFY_EXT); + set_bit(ATA_CMD_WRITE); + set_bit(ATA_CMD_WRITE_EXT); + set_bit(ATA_CMD_WRITE_FUA_EXT); + set_bit(ATA_CMD_WRITE_DMA_QUEUED); + set_bit(ATA_CMD_WRITE_DMA_QUEUED_EXT); + set_bit(ATA_CMD_WRITE_DMA_QUEUED_FUA_EXT); + set_bit(ATA_CMD_FPDMA_WRITE); + set_bit(ATA_CMD_WRITE_MULTI); + set_bit(ATA_CMD_WRITE_MULTI_EXT); + set_bit(ATA_CMD_WRITE_MULTI_FUA_EXT); + set_bit(ATA_CMD_PIO_WRITE); + set_bit(ATA_CMD_PIO_WRITE_EXT); + set_bit(ATA_CMD_WRITE_STREAM_DMA_EXT); + set_bit(ATA_CMD_WRITE_STREAM_EXT); +} + +void set_512_bits(void) +{ + set_bit(ATA_CMD_CFA_ERASE_SECTORS); + set_bit(ATA_CMD_CFA_REQUEST_EXT_ERROR); + set_bit(ATA_CMD_CHK_MEDIA_CARD_TYPE); + set_bit(ATA_CMD_CHK_POWER); + set_bit(ATA_CMD_CONFIG_STREAM); + set_bit(ATA_CMD_CONF_OVERLAY); + set_bit(ATA_CMD_DEV_RESET); + set_bit(ATA_CMD_DLOAD_MCODE); + set_bit(ATA_CMD_EDD); + set_bit(ATA_CMD_FLUSH); + set_bit(ATA_CMD_FLUSH_EXT); + set_bit(ATA_CMD_ID_ATA); + set_bit(ATA_CMD_ID_ATAPI); + set_bit(ATA_CMD_IDLE); + set_bit(ATA_CMD_IDLEIMMEDIATE); + set_bit(ATA_CMD_MEDIA_LOCK); + set_bit(ATA_CMD_MEDIA_UNLOCK); + set_bit(ATA_CMD_NVCACHE); + set_bit(ATA_CMD_NOP); + set_bit(ATA_CMD_PACKET); + set_bit(ATA_CMD_PMP_READ); + set_bit(ATA_CMD_READ_LOG_EXT); + set_bit(ATA_CMD_READ_LOG_DMA_EXT); + set_bit(ATA_CMD_READ_NATIVE_MAX); + set_bit(ATA_CMD_READ_NATIVE_MAX_EXT); + set_bit(ATA_CMD_RESTORE); + set_bit(ATA_CMD_SEC_DISABLE_PASSWORD); + set_bit(ATA_CMD_SEC_ERASE_PREPARE); + set_bit(ATA_CMD_SEC_ERASE_UNIT); + set_bit(ATA_CMD_SEC_FREEZE_LOCK); + set_bit(ATA_CMD_SEC_SET_PASSWORD); + set_bit(ATA_CMD_SEC_UNLOCK); + set_bit(ATA_CMD_SERVICE); + set_bit(ATA_CMD_SET_FEATURES); + set_bit(ATA_CMD_SET_MAX); + set_bit(ATA_CMD_SET_MAX_EXT); + set_bit(ATA_CMD_SET_MULTI); + set_bit(ATA_CMD_SLEEP); + set_bit(ATA_CMD_SMART); + set_bit(ATA_CMD_STANDBY); + set_bit(ATA_CMD_STANDBYNOW1); + set_bit(ATA_CMD_TRUSTED_NON_DATA); + set_bit(ATA_CMD_TRUSTED_RECEIVE); + set_bit(ATA_CMD_TRUSTED_RECEIVE_DMA); + set_bit(ATA_CMD_TRUSTED_SEND); + set_bit(ATA_CMD_TRUSTED_SEND_DMA); + set_bit(ATA_CMD_PMP_WRITE); + set_bit(ATA_CMD_WRITE_LOG_EXT); + set_bit(ATA_CMD_WRITE_LOG_DMA_EXT); + set_bit(ATA_CMD_WRITE_UNCORRECTABLE_EXT); + set_bit(ATA_CMD_INIT_DEV_PARAMS); + set_bit(ATA_EXABYTE_ENABLE_NEST); +} + +int main(int argc, char **argv) +{ + FILE *out; + + set_sector_bits(); + out = fopen("drivers/ata/sector-commands", "w"); + output_array(out); + fclose(out); + + set_512_bits(); + out = fopen("drivers/ata/all-commands", "w"); + output_array(out); + fclose(out); + + return 0; +} diff --git a/drivers/ata/bitops.c b/drivers/ata/bitops.c new file mode 100644 index 0000000..f6a6f06 --- /dev/null +++ b/drivers/ata/bitops.c @@ -0,0 +1,77 @@ +/* + * bitops.c + * + * Copyright 2008 Intel Corporation + * Author: Matthew Wilcox <wil...@linux.intel.com> + * + * This file is part of the Linux kernel, and is made available under + * the terms of the GNU General Public License, version 2 + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "bitops.h" + +static unsigned int *array; +static unsigned maxbit, allocbit; + +static void expand_array(unsigned bit) +{ + unsigned size; + void *tmp; + + if (bit > maxbit) + maxbit = bit; + if (bit < allocbit) + return; + + size = ((bit + 63) / 64) * 8; + tmp = realloc(array, size); + if (!tmp) { + fprintf(stderr, "Memory allocation failure\n"); + exit(1); + } + array = tmp; + memset(array + allocbit / 8, 0, size - allocbit / 8); + allocbit = size * 8; +} + +void set_bit(unsigned bit) +{ + expand_array(bit); + array[bit / 32] |= 1 << (bit % 32); +} + +static const char *sep(unsigned i, unsigned w) +{ + if (i >= w - 1) + return "\n"; + if (i % 6 == 5) + return "\n\t"; + return " "; +} + +void output_array(FILE *file) +{ + unsigned i, words = (maxbit + 32) / 32; + + fprintf(file, "{\n#ifdef CONFIG_64BIT\n\t"); + for (i = 0; i < words; i += 2) { + fprintf(file, "0x%08x%08xULL,%s", array[i + 1], array[i], + sep(i + 1, words)); + } + fprintf(file, "#else\n\t"); + for (i = 0; i < words; i++) { + fprintf(file, "0x%08x,%s", array[i], sep(i, words)); + } + fprintf(file, "#endif\n};\n"); +} + +void free_array(void) +{ + free(array); + array = NULL; + maxbit = allocbit = 0; +} diff --git a/drivers/ata/bitops.h b/drivers/ata/bitops.h new file mode 100644 index 0000000..3da560c --- /dev/null +++ b/drivers/ata/bitops.h @@ -0,0 +1,12 @@ +/* + * A library for creating statically initialised bit arrays + */ + +/* Call this to set a bit. */ +extern void set_bit(unsigned bit); + +/* Call this to output the array. */ +extern void output_array(FILE *file); + +/* Remove all bits from the array. */ +extern void free_array(void); diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c index 9fbf059..61378d8 100644 --- a/drivers/ata/libata-core.c +++ b/drivers/ata/libata-core.c @@ -600,6 +600,32 @@ void ata_tf_from_fis(const u8 *fis, struct ata_taskfile
*tf) tf->hob_nsect = fis[13]; }

+/** + * ata_sect_size - Returns the sector size to use for a command + * @command: The ATA command byte + * @dev_sect_size: The size of the drive's sectors + * + * Some commands are specified to transfer (a multiple of) 512 bytes of data + * while others transfer a multiple of the number of bytes in a sector. This + * function knows which commands transfer how much data. + */ +unsigned ata_sect_size(u8 command, unsigned dev_sect_size) +{ + static const unsigned long sector_commands[] = +#include "sector-commands" + static unsigned long known_commands[] = +#include "all-commands" + + if (test_bit(command, sector_commands)) + return dev_sect_size; + if (!test_bit(command, known_commands)) { + printk(KERN_ERR "Unknown ata cmd %d, assuming " + "512 byte sector size\n", command); + set_bit(command, known_commands); + } + return 512; +} + static const u8 ata_rw_cmds[] = { /* pio multi */ ATA_CMD_READ_MULTI, @@ -1333,6 +1359,25 @@ static u64 ata_id_n_sectors(const u16 *id) } }

+/* + * ATA supports sector sizes up to 2^33 - 1. The reported sector size may + * not be a power of two. The extra bytes are used for user-visible data + * integrity calculations. Note this is not the same as the ECC which is + * accessed through the SCT Command Transport or READ / WRITE LONG. + */ +static u64 ata_id_sect_size(const u16 *id) +{ + u16 word_106 = id[106]; + u64 sz; + + if ((word_106 & 0xc000) != 0x4000) + return ATA_SECT_SIZE; + if (!(word_106 & (1 << 12))) + return ATA_SECT_SIZE; + sz = (id[117] | ((u64)id[118] << 16)) * 2; + return sz; +} + u64 ata_tf_to_lba48(const struct ata_taskfile *tf) { u64 sectors = 0; @@ -2301,6 +2346,20 @@ static void ata_dev_config_ncq(struct ata_device *dev, snprintf(desc, desc_sz, "NCQ (depth %d/%d)", hdepth, ddepth); }

+static int ata_check_sect_size(struct ata_device *dev) +{ + /* Every host can handle 512 byte sectors */ + if (dev->sect_size == 512) + return 0; + /* Linux doesn't handle sectors larger than 4GB. This may be + * a problem around 2050 or so. Deal with it then. */ + if (dev->sect_size > 0xffffffffULL) + return -EINVAL; + if (!dev->link->ap->ops->sector_size_supported) + return -EINVAL; + return dev->link->ap->ops->sector_size_supported(dev) ? 0 : -EINVAL; +} + /** * ata_dev_configure - Configure the specified ATA/ATAPI device * @dev: Target device to configure @@ -2384,6 +2443,7 @@ int ata_dev_configure(struct ata_device *dev) dev->max_sectors = 0; dev->cdb_len = 0; dev->n_sectors = 0; + dev->sect_size = ATA_SECT_SIZE; dev->cylinders = 0; dev->heads = 0; dev->sectors = 0; @@ -2423,6 +2483,13 @@ int ata_dev_configure(struct ata_device *dev) }

dev->n_sectors = ata_id_n_sectors(id); + dev->sect_size = ata_id_sect_size(id); + rc = ata_check_sect_size(dev); + if (rc) { + ata_dev_printk(dev, KERN_ERR, "sector size %lld not " + "supported.\n", dev->sect_size); + goto err_out_nosup; + }

if (dev->id[59] & 0x100) dev->multi_count = dev->id[59] & 0xff; diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c index b9747fa..9e89601 100644 --- a/drivers/ata/libata-scsi.c +++ b/drivers/ata/libata-scsi.c @@ -50,7 +50,6 @@

#include "libata.h"

-#define SECTOR_SIZE 512 #define ATA_SCSI_RBUF_SIZE 4096

static DEFINE_SPINLOCK(ata_scsi_rbuf_lock); @@ -455,7 +454,7 @@ static int ata_get_identity(struct ata_port *ap, struct
scsi_device *sdev,

/** * ata_cmd_ioctl - Handler for HDIO_DRIVE_CMD ioctl - * @scsidev: Device to which we are issuing command + * @sdev: Device to which we are issuing command * @arg: User provided data for issuing command * * LOCKING: @@ -464,7 +463,7 @@ static int ata_get_identity(struct ata_port *ap, struct
scsi_device *sdev, * RETURNS: * Zero on success, negative errno on error. */ -int ata_cmd_ioctl(struct scsi_device *scsidev, void __user *arg) +int ata_cmd_ioctl(struct scsi_device *sdev, void __user *arg) { int rc = 0; u8 scsi_cmd[MAX_COMMAND_SIZE]; @@ -486,7 +485,8 @@ int ata_cmd_ioctl(struct scsi_device *scsidev, void __user
*arg) memset(scsi_cmd, 0, sizeof(scsi_cmd));

if (args[3]) { - argsize = SECTOR_SIZE * args[3]; + unsigned sect_size = ata_sect_size(args[0], sdev->sector_size); + argsize = sect_size * args[3]; argbuf = kmalloc(argsize, GFP_KERNEL); if (argbuf == NULL) { rc = -ENOMEM; @@ -518,7 +518,7 @@ int ata_cmd_ioctl(struct scsi_device *scsidev, void __user
*arg)

/* Good values for timeout and retries? Values below from scsi_ioctl_send_command() for default case... */ - cmd_result = scsi_execute(scsidev, scsi_cmd, data_dir, argbuf, argsize, + cmd_result = scsi_execute(sdev, scsi_cmd, data_dir, argbuf, argsize, sensebuf, (10*HZ), 5, 0, NULL);

if (driver_byte(cmd_result) == DRIVER_SENSE) {/* sense data available */ @@ -1630,6 +1630,7 @@ nothing_to_do: static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc) { struct scsi_cmnd *scmd = qc->scsicmd; + struct ata_device *dev = qc->dev; const u8 *cdb = scmd->cmnd; unsigned int tf_flags = 0; u64 block; @@ -1686,9 +1687,9 @@ static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd
*qc) goto nothing_to_do;

qc->flags |= ATA_QCFLAG_IO; - qc->nbytes = n_block * ATA_SECT_SIZE; + qc->nbytes = n_block * dev->sect_size;

- rc = ata_build_rw_tf(&qc->tf, qc->dev, block, n_block, tf_flags, + rc = ata_build_rw_tf(&qc->tf, dev, block, n_block, tf_flags, qc->tag); if (likely(rc == 0)) return 0; @@ -2354,10 +2355,25 @@ saving_not_supp: */ static unsigned int ata_scsiop_read_cap(struct ata_scsi_args *args, u8 *rbuf) { - u64 last_lba = args->dev->n_sectors - 1; /* LBA of the last block */ + struct ata_device *dev = args->dev; + u64 last_lba = dev->n_sectors - 1; /* LBA of the last block */ + u32 sector_size; + u8 log_per_phys = 1; + u16 first_sector_offset = 0; + u16 word_106 = dev->id[106];

VPRINTK("ENTER\n");

+ if ((word_106 & 0xc000) == 0x4000) { + /* Number and offset of logical sectors per physical sector */ + if (word_106 & (1 << 13)) + log_per_phys = word_106 & 0xf; + if ((dev->id[209] & 0xc000) == 0x4000) + first_sector_offset = dev->id[209] & 0x3fff; + } + + sector_size = dev->sect_size; + if (args->cmd->cmnd[0] == READ_CAPACITY) { if (last_lba >= 0xffffffffULL) last_lba = 0xffffffff; @@ -2368,9 +2384,10 @@ static unsigned int ata_scsiop_read_cap(struct
ata_scsi_args *args, u8 *rbuf) rbuf[2] = last_lba >> (8 * 1); rbuf[3] = last_lba;

- /* sector size */ - rbuf[6] = ATA_SECT_SIZE >> 8; - rbuf[7] = ATA_SECT_SIZE & 0xff; + rbuf[4] = sector_size >> (8 * 3); + rbuf[5] = sector_size >> (8 * 2); + rbuf[6] = sector_size >> (8 * 1); + rbuf[7] = sector_size; } else { /* sector count, 64-bit */ rbuf[0] = last_lba >> (8 * 7); @@ -2383,8 +2400,15 @@ static unsigned int ata_scsiop_read_cap(struct
ata_scsi_args *args, u8 *rbuf) rbuf[7] = last_lba;

/* sector size */ - rbuf[10] = ATA_SECT_SIZE >> 8; - rbuf[11] = ATA_SECT_SIZE & 0xff; + rbuf[8] = sector_size >> (8 * 3); + rbuf[9] = sector_size >> (8 * 2); + rbuf[10] = sector_size >> (8 * 1); + rbuf[11] = sector_size; + + rbuf[12] = 0; + rbuf[13] = log_per_phys; + rbuf[14] = first_sector_offset >> 8; + rbuf[15] = first_sector_offset; }

return 0; @@ -2858,7 +2882,7 @@ static unsigned int ata_scsi_pass_thru(struct
ata_queued_cmd *qc) }

/* READ/WRITE LONG use a non-standard sect_size */ - qc->sect_size = ATA_SECT_SIZE; + qc->sect_size = ata_sect_size(tf->command, dev->sect_size); switch (tf->command) { case ATA_CMD_READ_LONG: case ATA_CMD_READ_LONG_ONCE: diff --git a/include/linux/libata.h b/include/linux/libata.h index 5d87bc0..e0d17ec 100644 --- a/include/linux/libata.h +++ b/include/linux/libata.h @@ -583,6 +583,7 @@ struct ata_device { #endif /* n_sector is CLEAR_BEGIN, read comment above CLEAR_BEGIN */ u64 n_sectors; /* size of device, if ATA */ + u64 sect_size; /* Logical, not physical */ unsigned int class; /* ATA_DEV_xxx */ unsigned long unpark_deadline;

@@ -781,6 +782,7 @@ struct ata_port_operations { unsigned int (*read_id)(struct ata_device *dev, struct ata_taskfile *tf, u16
*id);

void (*dev_config)(struct ata_device *dev); + bool (*sector_size_supported)(struct ata_device *dev);

void (*freeze)(struct ata_port *ap); void (*thaw)(struct ata_port *ap); @@ -988,6 +990,7 @@ extern unsigned int ata_do_dev_read_id(struct ata_device
*dev, struct ata_taskfile *tf, u16 *id); extern void ata_qc_complete(struct ata_queued_cmd *qc); extern int ata_qc_complete_multiple(struct ata_port *ap, u32 qc_active); +extern unsigned ata_sect_size(u8 command, unsigned dev_sect_size); extern void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *)); extern int ata_std_bios_param(struct scsi_device *sdev,