Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5b8f2587 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'upstream-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jgarzik/libata-dev 

* 'upstream-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jgarzik/libata-dev:
  sata_sil: add Large Block Transfer support
  [libata] ata_piix: cleanup dmi strings checking
  DMI: add dmi_match
  libata: blacklist NCQ on OCZ CORE 2 SSD (resend)
  [libata] Update kernel-doc comments to match source code
  libata: perform port detach in EH
  libata: when restoring SControl during detach do the PMP links first
  libata: beef up iterators
parents 526ea064 c7e324f1

drivers/ata/ahci.c

+4 −4
Original line number Diff line number Diff line
@@ -1119,14 +1119,14 @@ static void ahci_start_port(struct ata_port *ap) 


	/* turn on LEDs */

	if (ap->flags & ATA_FLAG_EM) {

		ata_port_for_each_link(link, ap) {

		ata_for_each_link(link, ap, EDGE) {

			emp = &pp->em_priv[link->pmp];

			ahci_transmit_led_message(ap, emp->led_state, 4);

		}

	}



	if (ap->flags & ATA_FLAG_SW_ACTIVITY)

		ata_port_for_each_link(link, ap)

		ata_for_each_link(link, ap, EDGE)

			ahci_init_sw_activity(link);



}
@@ -1361,7 +1361,7 @@ static ssize_t ahci_led_show(struct ata_port *ap, char *buf) 
	struct ahci_em_priv *emp;

	int rc = 0;



	ata_port_for_each_link(link, ap) {

	ata_for_each_link(link, ap, EDGE) {

		emp = &pp->em_priv[link->pmp];

		rc += sprintf(buf, "%lx\n", emp->led_state);

	}
@@ -1941,7 +1941,7 @@ static void ahci_error_intr(struct ata_port *ap, u32 irq_stat) 
	u32 serror;



	/* determine active link */

	ata_port_for_each_link(link, ap)

	ata_for_each_link(link, ap, EDGE)

		if (ata_link_active(link))

			break;

	if (!link)

drivers/ata/ata_generic.c

+1 −4
Original line number Diff line number Diff line
@@ -57,10 +57,7 @@ static int generic_set_mode(struct ata_link *link, struct ata_device **unused) 
	if (pdev->vendor == PCI_VENDOR_ID_CENATEK)

		dma_enabled = 0xFF;



	ata_link_for_each_dev(dev, link) {

		if (!ata_dev_enabled(dev))

			continue;



	ata_for_each_dev(dev, link, ENABLED) {

		/* We don't really care */

		dev->pio_mode = XFER_PIO_0;

		dev->dma_mode = XFER_MW_DMA_0;

drivers/ata/ata_piix.c

+7 −14
Original line number Diff line number Diff line
@@ -1072,20 +1072,13 @@ static int piix_broken_suspend(void) 
	 * matching is necessary because dmi_system_id.matches is

	 * limited to four entries.

	 */

	if (dmi_get_system_info(DMI_SYS_VENDOR) &&

	    dmi_get_system_info(DMI_PRODUCT_NAME) &&

	    dmi_get_system_info(DMI_PRODUCT_VERSION) &&

	    dmi_get_system_info(DMI_PRODUCT_SERIAL) &&

	    dmi_get_system_info(DMI_BOARD_VENDOR) &&

	    dmi_get_system_info(DMI_BOARD_NAME) &&

	    dmi_get_system_info(DMI_BOARD_VERSION) &&

	    !strcmp(dmi_get_system_info(DMI_SYS_VENDOR), "TOSHIBA") &&

	    !strcmp(dmi_get_system_info(DMI_PRODUCT_NAME), "000000") &&

	    !strcmp(dmi_get_system_info(DMI_PRODUCT_VERSION), "000000") &&

	    !strcmp(dmi_get_system_info(DMI_PRODUCT_SERIAL), "000000") &&

	    !strcmp(dmi_get_system_info(DMI_BOARD_VENDOR), "TOSHIBA") &&

	    !strcmp(dmi_get_system_info(DMI_BOARD_NAME), "Portable PC") &&

	    !strcmp(dmi_get_system_info(DMI_BOARD_VERSION), "Version A0"))

	if (dmi_match(DMI_SYS_VENDOR, "TOSHIBA") &&

	    dmi_match(DMI_PRODUCT_NAME, "000000") &&

	    dmi_match(DMI_PRODUCT_VERSION, "000000") &&

	    dmi_match(DMI_PRODUCT_SERIAL, "000000") &&

	    dmi_match(DMI_BOARD_VENDOR, "TOSHIBA") &&

	    dmi_match(DMI_BOARD_NAME, "Portable PC") &&

	    dmi_match(DMI_BOARD_VERSION, "Version A0"))

		return 1;



	return 0;

drivers/ata/libata-acpi.c

+8 −11
Original line number Diff line number Diff line
@@ -89,7 +89,7 @@ void ata_acpi_associate_sata_port(struct ata_port *ap) 


		ap->link.device->acpi_handle = NULL;



		ata_port_for_each_link(link, ap) {

		ata_for_each_link(link, ap, EDGE) {

			acpi_integer adr = SATA_ADR(ap->port_no, link->pmp);



			link->device->acpi_handle =
@@ -129,8 +129,8 @@ static void ata_acpi_detach_device(struct ata_port *ap, struct ata_device *dev) 
		struct ata_link *tlink;

		struct ata_device *tdev;



		ata_port_for_each_link(tlink, ap)

			ata_link_for_each_dev(tdev, tlink)

		ata_for_each_link(tlink, ap, EDGE)

			ata_for_each_dev(tdev, tlink, ALL)

				tdev->flags |= ATA_DFLAG_DETACH;

	}
@@ -588,12 +588,9 @@ int ata_acpi_cbl_80wire(struct ata_port *ap, const struct ata_acpi_gtm *gtm) 
{

	struct ata_device *dev;



	ata_link_for_each_dev(dev, &ap->link) {

	ata_for_each_dev(dev, &ap->link, ENABLED) {

		unsigned long xfer_mask, udma_mask;



		if (!ata_dev_enabled(dev))

			continue;



		xfer_mask = ata_acpi_gtm_xfermask(dev, gtm);

		ata_unpack_xfermask(xfer_mask, NULL, NULL, &udma_mask);
@@ -893,7 +890,7 @@ void ata_acpi_on_resume(struct ata_port *ap) 
		 * use values set by _STM.  Cache _GTF result and

		 * schedule _GTF.

		 */

		ata_link_for_each_dev(dev, &ap->link) {

		ata_for_each_dev(dev, &ap->link, ALL) {

			ata_acpi_clear_gtf(dev);

			if (ata_dev_enabled(dev) &&

			    ata_dev_get_GTF(dev, NULL) >= 0)
@@ -904,7 +901,7 @@ void ata_acpi_on_resume(struct ata_port *ap) 
		 * there's no reason to evaluate IDE _GTF early

		 * without _STM.  Clear cache and schedule _GTF.

		 */

		ata_link_for_each_dev(dev, &ap->link) {

		ata_for_each_dev(dev, &ap->link, ALL) {

			ata_acpi_clear_gtf(dev);

			if (ata_dev_enabled(dev))

				dev->flags |= ATA_DFLAG_ACPI_PENDING;
@@ -932,8 +929,8 @@ void ata_acpi_set_state(struct ata_port *ap, pm_message_t state) 
	if (state.event == PM_EVENT_ON)

		acpi_bus_set_power(ap->acpi_handle, ACPI_STATE_D0);



	ata_link_for_each_dev(dev, &ap->link) {

		if (dev->acpi_handle && ata_dev_enabled(dev))

	ata_for_each_dev(dev, &ap->link, ENABLED) {

		if (dev->acpi_handle)

			acpi_bus_set_power(dev->acpi_handle,

				state.event == PM_EVENT_ON ?

					ACPI_STATE_D0 : ACPI_STATE_D3);

drivers/ata/libata-core.c

+125 −79
Original line number Diff line number Diff line
@@ -163,42 +163,118 @@ MODULE_LICENSE("GPL"); 
MODULE_VERSION(DRV_VERSION);





/*

 * Iterator helpers.  Don't use directly.

/**

 *	ata_link_next - link iteration helper

 *	@link: the previous link, NULL to start

 *	@ap: ATA port containing links to iterate

 *	@mode: iteration mode, one of ATA_LITER_*

 *

 *	LOCKING:

 *	Host lock or EH context.

 *

 *	RETURNS:

 *	Pointer to the next link.

 */

struct ata_link *__ata_port_next_link(struct ata_port *ap,

				      struct ata_link *link, bool dev_only)

struct ata_link *ata_link_next(struct ata_link *link, struct ata_port *ap,

			       enum ata_link_iter_mode mode)

{

	BUG_ON(mode != ATA_LITER_EDGE &&

	       mode != ATA_LITER_PMP_FIRST && mode != ATA_LITER_HOST_FIRST);



	/* NULL link indicates start of iteration */

	if (!link) {

		if (dev_only && sata_pmp_attached(ap))

	if (!link)

		switch (mode) {

		case ATA_LITER_EDGE:

		case ATA_LITER_PMP_FIRST:

			if (sata_pmp_attached(ap))

				return ap->pmp_link;

			/* fall through */

		case ATA_LITER_HOST_FIRST:

			return &ap->link;

		}



	/* we just iterated over the host master link, what's next? */

	if (link == &ap->link) {

		if (!sata_pmp_attached(ap)) {

			if (unlikely(ap->slave_link) && !dev_only)

	/* we just iterated over the host link, what's next? */

	if (link == &ap->link)

		switch (mode) {

		case ATA_LITER_HOST_FIRST:

			if (sata_pmp_attached(ap))

				return ap->pmp_link;

			/* fall through */

		case ATA_LITER_PMP_FIRST:

			if (unlikely(ap->slave_link))

				return ap->slave_link;

			/* fall through */

		case ATA_LITER_EDGE:

			return NULL;

		}

		return ap->pmp_link;

	}



	/* slave_link excludes PMP */

	if (unlikely(link == ap->slave_link))

		return NULL;



	/* iterate to the next PMP link */

	/* we were over a PMP link */

	if (++link < ap->pmp_link + ap->nr_pmp_links)

		return link;



	if (mode == ATA_LITER_PMP_FIRST)

		return &ap->link;



	return NULL;

}



/**

 *	ata_dev_next - device iteration helper

 *	@dev: the previous device, NULL to start

 *	@link: ATA link containing devices to iterate

 *	@mode: iteration mode, one of ATA_DITER_*

 *

 *	LOCKING:

 *	Host lock or EH context.

 *

 *	RETURNS:

 *	Pointer to the next device.

 */

struct ata_device *ata_dev_next(struct ata_device *dev, struct ata_link *link,

				enum ata_dev_iter_mode mode)

{

	BUG_ON(mode != ATA_DITER_ENABLED && mode != ATA_DITER_ENABLED_REVERSE &&

	       mode != ATA_DITER_ALL && mode != ATA_DITER_ALL_REVERSE);



	/* NULL dev indicates start of iteration */

	if (!dev)

		switch (mode) {

		case ATA_DITER_ENABLED:

		case ATA_DITER_ALL:

			dev = link->device;

			goto check;

		case ATA_DITER_ENABLED_REVERSE:

		case ATA_DITER_ALL_REVERSE:

			dev = link->device + ata_link_max_devices(link) - 1;

			goto check;

		}



 next:

	/* move to the next one */

	switch (mode) {

	case ATA_DITER_ENABLED:

	case ATA_DITER_ALL:

		if (++dev < link->device + ata_link_max_devices(link))

			goto check;

		return NULL;

	case ATA_DITER_ENABLED_REVERSE:

	case ATA_DITER_ALL_REVERSE:

		if (--dev >= link->device)

			goto check;

		return NULL;

	}



 check:

	if ((mode == ATA_DITER_ENABLED || mode == ATA_DITER_ENABLED_REVERSE) &&

	    !ata_dev_enabled(dev))

		goto next;

	return dev;

}



/**

 *	ata_dev_phys_link - find physical link for a device

 *	@dev: ATA device to look up physical link for
@@ -1107,8 +1183,8 @@ static void ata_lpm_enable(struct ata_host *host) 


	for (i = 0; i < host->n_ports; i++) {

		ap = host->ports[i];

		ata_port_for_each_link(link, ap) {

			ata_link_for_each_dev(dev, link)

		ata_for_each_link(link, ap, EDGE) {

			ata_for_each_dev(dev, link, ALL)

				ata_dev_disable_pm(dev);

		}

	}
@@ -2594,11 +2670,11 @@ int ata_bus_probe(struct ata_port *ap) 


	ata_port_probe(ap);



	ata_link_for_each_dev(dev, &ap->link)

	ata_for_each_dev(dev, &ap->link, ALL)

		tries[dev->devno] = ATA_PROBE_MAX_TRIES;



 retry:

	ata_link_for_each_dev(dev, &ap->link) {

	ata_for_each_dev(dev, &ap->link, ALL) {

		/* If we issue an SRST then an ATA drive (not ATAPI)

		 * may change configuration and be in PIO0 timing. If

		 * we do a hard reset (or are coming from power on)
@@ -2620,7 +2696,7 @@ int ata_bus_probe(struct ata_port *ap) 
	/* reset and determine device classes */

	ap->ops->phy_reset(ap);



	ata_link_for_each_dev(dev, &ap->link) {

	ata_for_each_dev(dev, &ap->link, ALL) {

		if (!(ap->flags & ATA_FLAG_DISABLED) &&

		    dev->class != ATA_DEV_UNKNOWN)

			classes[dev->devno] = dev->class;
@@ -2636,7 +2712,7 @@ int ata_bus_probe(struct ata_port *ap) 
	   specific sequence bass-ackwards so that PDIAG- is released by

	   the slave device */



	ata_link_for_each_dev_reverse(dev, &ap->link) {

	ata_for_each_dev(dev, &ap->link, ALL_REVERSE) {

		if (tries[dev->devno])

			dev->class = classes[dev->devno];
@@ -2653,24 +2729,19 @@ int ata_bus_probe(struct ata_port *ap) 
	if (ap->ops->cable_detect)

		ap->cbl = ap->ops->cable_detect(ap);



	/* We may have SATA bridge glue hiding here irrespective of the

	   reported cable types and sensed types */

	ata_link_for_each_dev(dev, &ap->link) {

		if (!ata_dev_enabled(dev))

			continue;

		/* SATA drives indicate we have a bridge. We don't know which

		   end of the link the bridge is which is a problem */

	/* We may have SATA bridge glue hiding here irrespective of

	 * the reported cable types and sensed types.  When SATA

	 * drives indicate we have a bridge, we don't know which end

	 * of the link the bridge is which is a problem.

	 */

	ata_for_each_dev(dev, &ap->link, ENABLED)

		if (ata_id_is_sata(dev->id))

			ap->cbl = ATA_CBL_SATA;

	}



	/* After the identify sequence we can now set up the devices. We do

	   this in the normal order so that the user doesn't get confused */



	ata_link_for_each_dev(dev, &ap->link) {

		if (!ata_dev_enabled(dev))

			continue;



	ata_for_each_dev(dev, &ap->link, ENABLED) {

		ap->link.eh_context.i.flags |= ATA_EHI_PRINTINFO;

		rc = ata_dev_configure(dev);

		ap->link.eh_context.i.flags &= ~ATA_EHI_PRINTINFO;
@@ -2683,8 +2754,7 @@ int ata_bus_probe(struct ata_port *ap) 
	if (rc)

		goto fail;



	ata_link_for_each_dev(dev, &ap->link)

		if (ata_dev_enabled(dev))

	ata_for_each_dev(dev, &ap->link, ENABLED)

		return 0;



	/* no device present, disable port */
@@ -3331,13 +3401,10 @@ int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev) 
	int rc = 0, used_dma = 0, found = 0;



	/* step 1: calculate xfer_mask */

	ata_link_for_each_dev(dev, link) {

	ata_for_each_dev(dev, link, ENABLED) {

		unsigned long pio_mask, dma_mask;

		unsigned int mode_mask;



		if (!ata_dev_enabled(dev))

			continue;



		mode_mask = ATA_DMA_MASK_ATA;

		if (dev->class == ATA_DEV_ATAPI)

			mode_mask = ATA_DMA_MASK_ATAPI;
@@ -3366,10 +3433,7 @@ int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev) 
		goto out;



	/* step 2: always set host PIO timings */

	ata_link_for_each_dev(dev, link) {

		if (!ata_dev_enabled(dev))

			continue;



	ata_for_each_dev(dev, link, ENABLED) {

		if (dev->pio_mode == 0xff) {

			ata_dev_printk(dev, KERN_WARNING, "no PIO support\n");

			rc = -EINVAL;
@@ -3383,8 +3447,8 @@ int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev) 
	}



	/* step 3: set host DMA timings */

	ata_link_for_each_dev(dev, link) {

		if (!ata_dev_enabled(dev) || !ata_dma_enabled(dev))

	ata_for_each_dev(dev, link, ENABLED) {

		if (!ata_dma_enabled(dev))

			continue;



		dev->xfer_mode = dev->dma_mode;
@@ -3394,11 +3458,7 @@ int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev) 
	}



	/* step 4: update devices' xfer mode */

	ata_link_for_each_dev(dev, link) {

		/* don't update suspended devices' xfer mode */

		if (!ata_dev_enabled(dev))

			continue;



	ata_for_each_dev(dev, link, ENABLED) {

		rc = ata_dev_set_mode(dev);

		if (rc)

			goto out;
@@ -4048,6 +4108,7 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = { 
	{ "Maxtor 7V300F0",	"VA111630",	ATA_HORKAGE_NONCQ },

	{ "ST380817AS",		"3.42",		ATA_HORKAGE_NONCQ },

	{ "ST3160023AS",	"3.42",		ATA_HORKAGE_NONCQ },

	{ "OCZ CORE_SSD",	"02.10104",	ATA_HORKAGE_NONCQ },



	/* Seagate NCQ + FLUSH CACHE firmware bug */

	{ "ST31500341AS",	"SD15",		ATA_HORKAGE_NONCQ |
@@ -4263,9 +4324,9 @@ static int cable_is_40wire(struct ata_port *ap) 
	 * - if you have a non detect capable drive you don't want it

	 *   to colour the choice

	 */

	ata_port_for_each_link(link, ap) {

		ata_link_for_each_dev(dev, link) {

			if (ata_dev_enabled(dev) && !ata_is_40wire(dev))

	ata_for_each_link(link, ap, EDGE) {

		ata_for_each_dev(dev, link, ENABLED) {

			if (!ata_is_40wire(dev))

				return 0;

		}

	}
@@ -4672,7 +4733,6 @@ static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap) 
/**

 *	ata_qc_new_init - Request an available ATA command, and initialize it

 *	@dev: Device from whom we request an available command structure

 *	@tag: command tag

 *

 *	LOCKING:

 *	None.
@@ -5218,7 +5278,7 @@ static int ata_host_request_pm(struct ata_host *host, pm_message_t mesg, 
		}



		ap->pflags |= ATA_PFLAG_PM_PENDING;

		__ata_port_for_each_link(link, ap) {

		ata_for_each_link(link, ap, HOST_FIRST) {

			link->eh_info.action |= action;

			link->eh_info.flags |= ehi_flags;

		}
@@ -6047,8 +6107,6 @@ int ata_host_activate(struct ata_host *host, int irq, 
static void ata_port_detach(struct ata_port *ap)

{

	unsigned long flags;

	struct ata_link *link;

	struct ata_device *dev;



	if (!ap->ops->error_handler)

		goto skip_eh;
@@ -6056,28 +6114,15 @@ static void ata_port_detach(struct ata_port *ap) 
	/* tell EH we're leaving & flush EH */

	spin_lock_irqsave(ap->lock, flags);

	ap->pflags |= ATA_PFLAG_UNLOADING;

	ata_port_schedule_eh(ap);

	spin_unlock_irqrestore(ap->lock, flags);



	/* wait till EH commits suicide */

	ata_port_wait_eh(ap);



	/* EH is now guaranteed to see UNLOADING - EH context belongs

	 * to us.  Restore SControl and disable all existing devices.

	 */

	__ata_port_for_each_link(link, ap) {

		sata_scr_write(link, SCR_CONTROL, link->saved_scontrol & 0xff0);

		ata_link_for_each_dev(dev, link)

			ata_dev_disable(dev);

	}



	/* Final freeze & EH.  All in-flight commands are aborted.  EH

	 * will be skipped and retrials will be terminated with bad

	 * target.

	 */

	spin_lock_irqsave(ap->lock, flags);

	ata_port_freeze(ap);	/* won't be thawed */

	spin_unlock_irqrestore(ap->lock, flags);

	/* it better be dead now */

	WARN_ON(!(ap->pflags & ATA_PFLAG_UNLOADED));



	ata_port_wait_eh(ap);

	cancel_rearming_delayed_work(&ap->hotplug_task);



 skip_eh:
@@ -6528,7 +6573,8 @@ EXPORT_SYMBOL_GPL(ata_base_port_ops); 
EXPORT_SYMBOL_GPL(sata_port_ops);

EXPORT_SYMBOL_GPL(ata_dummy_port_ops);

EXPORT_SYMBOL_GPL(ata_dummy_port_info);

EXPORT_SYMBOL_GPL(__ata_port_next_link);

EXPORT_SYMBOL_GPL(ata_link_next);

EXPORT_SYMBOL_GPL(ata_dev_next);

EXPORT_SYMBOL_GPL(ata_std_bios_param);

EXPORT_SYMBOL_GPL(ata_host_init);

EXPORT_SYMBOL_GPL(ata_host_alloc);