Merge branch 'upstream-linus' of master.kernel.org:/pub/scm/linux/kernel/git/jgarzik/libata-dev (03529d9f) · Commits · e / devices / samsung / android_kernel_samsung_exynos7420

drivers/ide/pci/amd74xx.c

+5 −2

Original line number	Original line	Diff line number	Diff line
	@@ -75,6 +75,7 @@ static struct amd_ide_chip {
	{ PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_IDE, 0x50, AMD_UDMA_133 },		{ PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_IDE, 0x50, AMD_UDMA_133 },
	{ PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_IDE, 0x50, AMD_UDMA_133 },		{ PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_IDE, 0x50, AMD_UDMA_133 },
	{ PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_IDE, 0x50, AMD_UDMA_133 },		{ PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_IDE, 0x50, AMD_UDMA_133 },
			{ PCI_DEVICE_ID_NVIDIA_NFORCE_MCP65_IDE, 0x50, AMD_UDMA_133 },
	{ PCI_DEVICE_ID_AMD_CS5536_IDE, 0x40, AMD_UDMA_100 },		{ PCI_DEVICE_ID_AMD_CS5536_IDE, 0x40, AMD_UDMA_100 },
	{ 0 }		{ 0 }
	};		};
	@@ -490,7 +491,8 @@ static ide_pci_device_t amd74xx_chipsets[] __devinitdata = {
	/* 15 */ DECLARE_NV_DEV("NFORCE-MCP51"),		/* 15 */ DECLARE_NV_DEV("NFORCE-MCP51"),
	/* 16 */ DECLARE_NV_DEV("NFORCE-MCP55"),		/* 16 */ DECLARE_NV_DEV("NFORCE-MCP55"),
	/* 17 */ DECLARE_NV_DEV("NFORCE-MCP61"),		/* 17 */ DECLARE_NV_DEV("NFORCE-MCP61"),
	/* 18 */ DECLARE_AMD_DEV("AMD5536"),		/* 18 */ DECLARE_NV_DEV("NFORCE-MCP65"),
			/* 19 */ DECLARE_AMD_DEV("AMD5536"),
	};		};

	static int __devinit amd74xx_probe(struct pci_dev dev, const struct pci_device_id id)		static int __devinit amd74xx_probe(struct pci_dev dev, const struct pci_device_id id)
	@@ -528,7 +530,8 @@ static struct pci_device_id amd74xx_pci_tbl[] = {
	{ PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 15 },		{ PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 15 },
	{ PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 16 },		{ PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 16 },
	{ PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 17 },		{ PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 17 },
	{ PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CS5536_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 18 },		{ PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP65_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 18 },
			{ PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CS5536_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 19 },
	{ 0, },		{ 0, },
	};		};
	MODULE_DEVICE_TABLE(pci, amd74xx_pci_tbl);		MODULE_DEVICE_TABLE(pci, amd74xx_pci_tbl);

drivers/scsi/Kconfig

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -501,7 +501,7 @@ config SCSI_ATA_PIIX
	tristate "Intel PIIX/ICH SATA support"		tristate "Intel PIIX/ICH SATA support"
	depends on SCSI_SATA && PCI		depends on SCSI_SATA && PCI
	help		help
	This option enables support for ICH5 Serial ATA.		This option enables support for ICH5/6/7/8 Serial ATA.
	If PATA support was enabled previously, this enables		If PATA support was enabled previously, this enables
	support for select Intel PIIX/ICH PATA host controllers.		support for select Intel PIIX/ICH PATA host controllers.

drivers/scsi/ahci.c

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -48,7 +48,7 @@
	#include <asm/io.h>		#include <asm/io.h>

	#define DRV_NAME "ahci"		#define DRV_NAME "ahci"
	#define DRV_VERSION "1.3"		#define DRV_VERSION "2.0"


	enum {		enum {

drivers/scsi/ata_piix.c

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -93,7 +93,7 @@
	#include <linux/libata.h>		#include <linux/libata.h>

	#define DRV_NAME "ata_piix"		#define DRV_NAME "ata_piix"
	#define DRV_VERSION "1.10"		#define DRV_VERSION "2.00"

	enum {		enum {
	PIIX_IOCFG = 0x54, /* IDE I/O configuration register */		PIIX_IOCFG = 0x54, /* IDE I/O configuration register */

drivers/scsi/libata-core.c

+94 −57

Original line number	Original line	Diff line number	Diff line
	@@ -88,6 +88,10 @@ int libata_fua = 0;
	module_param_named(fua, libata_fua, int, 0444);		module_param_named(fua, libata_fua, int, 0444);
	MODULE_PARM_DESC(fua, "FUA support (0=off, 1=on)");		MODULE_PARM_DESC(fua, "FUA support (0=off, 1=on)");

			static int ata_probe_timeout = ATA_TMOUT_INTERNAL / HZ;
			module_param(ata_probe_timeout, int, 0444);
			MODULE_PARM_DESC(ata_probe_timeout, "Set ATA probing timeout (seconds)");

	MODULE_AUTHOR("Jeff Garzik");		MODULE_AUTHOR("Jeff Garzik");
	MODULE_DESCRIPTION("Library module for ATA devices");		MODULE_DESCRIPTION("Library module for ATA devices");
	MODULE_LICENSE("GPL");		MODULE_LICENSE("GPL");
	@@ -777,11 +781,9 @@ void ata_std_dev_select (struct ata_port *ap, unsigned int device)
	void ata_dev_select(struct ata_port *ap, unsigned int device,		void ata_dev_select(struct ata_port *ap, unsigned int device,
	unsigned int wait, unsigned int can_sleep)		unsigned int wait, unsigned int can_sleep)
	{		{
	if (ata_msg_probe(ap)) {		if (ata_msg_probe(ap))
	ata_port_printk(ap, KERN_INFO, "ata_dev_select: ENTER, ata%u: "		ata_port_printk(ap, KERN_INFO, "ata_dev_select: ENTER, ata%u: "
	"device %u, wait %u\n",		"device %u, wait %u\n", ap->id, device, wait);
	ap->id, device, wait);
	}

	if (wait)		if (wait)
	ata_wait_idle(ap);		ata_wait_idle(ap);
	@@ -950,7 +952,8 @@ void ata_port_flush_task(struct ata_port *ap)
	*/		*/
	if (!cancel_delayed_work(&ap->port_task)) {		if (!cancel_delayed_work(&ap->port_task)) {
	if (ata_msg_ctl(ap))		if (ata_msg_ctl(ap))
	ata_port_printk(ap, KERN_DEBUG, "%s: flush #2\n", __FUNCTION__);		ata_port_printk(ap, KERN_DEBUG, "%s: flush #2\n",
			__FUNCTION__);
	flush_workqueue(ata_wq);		flush_workqueue(ata_wq);
	}		}

	@@ -1059,7 +1062,7 @@ unsigned ata_exec_internal(struct ata_device *dev,

	spin_unlock_irqrestore(ap->lock, flags);		spin_unlock_irqrestore(ap->lock, flags);

	rc = wait_for_completion_timeout(&wait, ATA_TMOUT_INTERNAL);		rc = wait_for_completion_timeout(&wait, ata_probe_timeout);

	ata_port_flush_task(ap);		ata_port_flush_task(ap);

	@@ -1131,6 +1134,33 @@ unsigned ata_exec_internal(struct ata_device *dev,
	return err_mask;		return err_mask;
	}		}

			/**
			* ata_do_simple_cmd - execute simple internal command
			* @dev: Device to which the command is sent
			* @cmd: Opcode to execute
			*
			* Execute a 'simple' command, that only consists of the opcode
			* 'cmd' itself, without filling any other registers
			*
			* LOCKING:
			* Kernel thread context (may sleep).
			*
			* RETURNS:
			* Zero on success, AC_ERR_* mask on failure
			*/
			unsigned int ata_do_simple_cmd(struct ata_device *dev, u8 cmd)
			{
			struct ata_taskfile tf;

			ata_tf_init(dev, &tf);

			tf.command = cmd;
			tf.flags \|= ATA_TFLAG_DEVICE;
			tf.protocol = ATA_PROT_NODATA;

			return ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
			}

	/**		/**
	* ata_pio_need_iordy - check if iordy needed		* ata_pio_need_iordy - check if iordy needed
	* @adev: ATA device		* @adev: ATA device
	@@ -1318,7 +1348,8 @@ int ata_dev_configure(struct ata_device *dev, int print_info)
	int i, rc;		int i, rc;

	if (!ata_dev_enabled(dev) && ata_msg_info(ap)) {		if (!ata_dev_enabled(dev) && ata_msg_info(ap)) {
	ata_dev_printk(dev, KERN_INFO, "%s: ENTER/EXIT (host %u, dev %u) -- nodev\n",		ata_dev_printk(dev, KERN_INFO,
			"%s: ENTER/EXIT (host %u, dev %u) -- nodev\n",
	__FUNCTION__, ap->id, dev->devno);		__FUNCTION__, ap->id, dev->devno);
	return 0;		return 0;
	}		}
	@@ -1329,8 +1360,9 @@ int ata_dev_configure(struct ata_device *dev, int print_info)

	/* print device capabilities */		/* print device capabilities */
	if (ata_msg_probe(ap))		if (ata_msg_probe(ap))
	ata_dev_printk(dev, KERN_DEBUG, "%s: cfg 49:%04x 82:%04x 83:%04x "		ata_dev_printk(dev, KERN_DEBUG,
	"84:%04x 85:%04x 86:%04x 87:%04x 88:%04x\n",		"%s: cfg 49:%04x 82:%04x 83:%04x 84:%04x "
			"85:%04x 86:%04x 87:%04x 88:%04x\n",
	__FUNCTION__,		__FUNCTION__,
	id[49], id[82], id[83], id[84],		id[49], id[82], id[83], id[84],
	id[85], id[86], id[87], id[88]);		id[85], id[86], id[87], id[88]);
	@@ -1402,13 +1434,15 @@ int ata_dev_configure(struct ata_device *dev, int print_info)
	ata_id_major_version(id),		ata_id_major_version(id),
	ata_mode_string(xfer_mask),		ata_mode_string(xfer_mask),
	(unsigned long long)dev->n_sectors,		(unsigned long long)dev->n_sectors,
	dev->cylinders, dev->heads, dev->sectors);		dev->cylinders, dev->heads,
			dev->sectors);
	}		}

	if (dev->id[59] & 0x100) {		if (dev->id[59] & 0x100) {
	dev->multi_count = dev->id[59] & 0xff;		dev->multi_count = dev->id[59] & 0xff;
	if (ata_msg_info(ap))		if (ata_msg_info(ap))
	ata_dev_printk(dev, KERN_INFO, "ata%u: dev %u multi count %u\n",		ata_dev_printk(dev, KERN_INFO,
			"ata%u: dev %u multi count %u\n",
	ap->id, dev->devno, dev->multi_count);		ap->id, dev->devno, dev->multi_count);
	}		}

	@@ -4946,31 +4980,9 @@ int ata_port_offline(struct ata_port *ap)
	return 0;		return 0;
	}		}

	/*		int ata_flush_cache(struct ata_device *dev)
	* Execute a 'simple' command, that only consists of the opcode 'cmd' itself,
	* without filling any other registers
	*/
	static int ata_do_simple_cmd(struct ata_device *dev, u8 cmd)
	{
	struct ata_taskfile tf;
	int err;

	ata_tf_init(dev, &tf);

	tf.command = cmd;
	tf.flags \|= ATA_TFLAG_DEVICE;
	tf.protocol = ATA_PROT_NODATA;

	err = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
	if (err)
	ata_dev_printk(dev, KERN_ERR, "%s: ata command failed: %d\n",
	__FUNCTION__, err);

	return err;
	}

	static int ata_flush_cache(struct ata_device *dev)
	{		{
			unsigned int err_mask;
	u8 cmd;		u8 cmd;

	if (!ata_try_flush_cache(dev))		if (!ata_try_flush_cache(dev))
	@@ -4981,17 +4993,41 @@ static int ata_flush_cache(struct ata_device *dev)
	else		else
	cmd = ATA_CMD_FLUSH;		cmd = ATA_CMD_FLUSH;

	return ata_do_simple_cmd(dev, cmd);		err_mask = ata_do_simple_cmd(dev, cmd);
			if (err_mask) {
			ata_dev_printk(dev, KERN_ERR, "failed to flush cache\n");
			return -EIO;
			}

			return 0;
	}		}

	static int ata_standby_drive(struct ata_device *dev)		static int ata_standby_drive(struct ata_device *dev)
	{		{
	return ata_do_simple_cmd(dev, ATA_CMD_STANDBYNOW1);		unsigned int err_mask;

			err_mask = ata_do_simple_cmd(dev, ATA_CMD_STANDBYNOW1);
			if (err_mask) {
			ata_dev_printk(dev, KERN_ERR, "failed to standby drive "
			"(err_mask=0x%x)\n", err_mask);
			return -EIO;
			}

			return 0;
	}		}

	static int ata_start_drive(struct ata_device *dev)		static int ata_start_drive(struct ata_device *dev)
	{		{
	return ata_do_simple_cmd(dev, ATA_CMD_IDLEIMMEDIATE);		unsigned int err_mask;

			err_mask = ata_do_simple_cmd(dev, ATA_CMD_IDLEIMMEDIATE);
			if (err_mask) {
			ata_dev_printk(dev, KERN_ERR, "failed to start drive "
			"(err_mask=0x%x)\n", err_mask);
			return -EIO;
			}

			return 0;
	}		}

	/**		/**
	@@ -5709,6 +5745,7 @@ int ata_pci_device_resume(struct pci_dev *pdev)

	static int __init ata_init(void)		static int __init ata_init(void)
	{		{
			ata_probe_timeout *= HZ;
	ata_wq = create_workqueue("ata");		ata_wq = create_workqueue("ata");
	if (!ata_wq)		if (!ata_wq)
	return -ENOMEM;		return -ENOMEM;