Merge branch 'upstream-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jgarzik/libata-dev (5b8f2587) · Commits · 戴 / test

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);

Admin message