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

Commit c13e69b2 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

Pull libata updates from Jeff Garzik:

 - More ACPI fixes

 - ata_piix: cosmetic code movement, re-enable MS Virtual PC support

 - generic platform driver improvements; use common code

 - pata_cs5536: add quirk for broken udma

 - printk prettiness (dev_printk becomes dev_info, etc.)

 - sata_promise: fix hardreset lockdep error

 - minor cleanups from Sergei Shtylyov

 - minor, automated cleanups from Wei Yongjun

 - fix null ptr deref bug, in sysfs API

* tag 'upstream-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jgarzik/libata-dev: (37 commits)
  sata_dwc_460ex: remove file exec bit (chmod 0755 -> 0644)
  [libata] fix Null pointer dereference on disk error
  ahci: convert ata_link_printk() to ata_link_warn()
  pata_imx: convert ata_dev_printk() to ata_dev_info()
  ARM: ep93xx: convert ata_<foo>_printk() to ata_<foo>_<level>()
  ahci_platform: make structs static
  Revert "pata_octeon_cf: perform host detach, removal on exit"
  Revert "libata: check SATA_SETTINGS log with HW Feature Ctrl"
  pata_of_platform: fix compile error
  libata: use pci_get_drvdata() helper
  pata_octeon_cf: perform host detach, removal on exit
  sata_highbank: utilize common ata_platform_remove_one()
  pata_palmld: utilize common ata_platform_remove_one()
  pata_platform: remove unused remove function
  pata_platform: utilize common ata_platform_remove_one()
  pata_of_platform: utilize common ata_platform_remove_one()
  pata_mpc52xx: utilize common ata_platform_remove_one()
  pata_ixp4xx_cf: utilize common ata_platform_remove_one()
  ahci_platform: utilize common ata_platform_remove_one()
  libata: implement ata_platform_remove_one()
  ...
parents c5258190 72d5f2da

drivers/ata/ahci_platform.c

+21 −25
Original line number Diff line number Diff line
@@ -25,6 +25,8 @@ 
#include <linux/ahci_platform.h>

#include "ahci.h"



static void ahci_host_stop(struct ata_host *host);



enum ahci_type {

	AHCI,		/* standard platform ahci */

	IMX53_AHCI,	/* ahci on i.mx53 */
@@ -47,6 +49,15 @@ static struct platform_device_id ahci_devtype[] = { 
};

MODULE_DEVICE_TABLE(platform, ahci_devtype);



static struct ata_port_operations ahci_platform_ops = {

	.inherits	= &ahci_ops,

	.host_stop	= ahci_host_stop,

};



static struct ata_port_operations ahci_platform_retry_srst_ops = {

	.inherits	= &ahci_pmp_retry_srst_ops,

	.host_stop	= ahci_host_stop,

};



static const struct ata_port_info ahci_port_info[] = {

	/* by features */
@@ -54,20 +65,20 @@ static const struct ata_port_info ahci_port_info[] = { 
		.flags		= AHCI_FLAG_COMMON,

		.pio_mask	= ATA_PIO4,

		.udma_mask	= ATA_UDMA6,

		.port_ops	= &ahci_ops,

		.port_ops	= &ahci_platform_ops,

	},

	[IMX53_AHCI] = {

		.flags		= AHCI_FLAG_COMMON,

		.pio_mask	= ATA_PIO4,

		.udma_mask	= ATA_UDMA6,

		.port_ops	= &ahci_pmp_retry_srst_ops,

		.port_ops	= &ahci_platform_retry_srst_ops,

	},

	[STRICT_AHCI] = {

		AHCI_HFLAGS	(AHCI_HFLAG_DELAY_ENGINE),

		.flags		= AHCI_FLAG_COMMON,

		.pio_mask	= ATA_PIO4,

		.udma_mask	= ATA_UDMA6,

		.port_ops	= &ahci_ops,

		.port_ops	= &ahci_platform_ops,

	},

};
@@ -75,7 +86,7 @@ static struct scsi_host_template ahci_platform_sht = { 
	AHCI_SHT("ahci_platform"),

};



static int __init ahci_probe(struct platform_device *pdev)

static int __devinit ahci_probe(struct platform_device *pdev)

{

	struct device *dev = &pdev->dev;

	struct ahci_platform_data *pdata = dev_get_platdata(dev);
@@ -218,15 +229,12 @@ static int __init ahci_probe(struct platform_device *pdev) 
	return rc;

}



static int __devexit ahci_remove(struct platform_device *pdev)

static void ahci_host_stop(struct ata_host *host)

{

	struct device *dev = &pdev->dev;

	struct device *dev = host->dev;

	struct ahci_platform_data *pdata = dev_get_platdata(dev);

	struct ata_host *host = dev_get_drvdata(dev);

	struct ahci_host_priv *hpriv = host->private_data;



	ata_host_detach(host);



	if (pdata && pdata->exit)

		pdata->exit(dev);
@@ -234,8 +242,6 @@ static int __devexit ahci_remove(struct platform_device *pdev) 
		clk_disable_unprepare(hpriv->clk);

		clk_put(hpriv->clk);

	}



	return 0;

}



#ifdef CONFIG_PM_SLEEP
@@ -317,7 +323,7 @@ static int ahci_resume(struct device *dev) 
}

#endif



SIMPLE_DEV_PM_OPS(ahci_pm_ops, ahci_suspend, ahci_resume);

static SIMPLE_DEV_PM_OPS(ahci_pm_ops, ahci_suspend, ahci_resume);



static const struct of_device_id ahci_of_match[] = {

	{ .compatible = "snps,spear-ahci", },
@@ -326,7 +332,8 @@ static const struct of_device_id ahci_of_match[] = { 
MODULE_DEVICE_TABLE(of, ahci_of_match);



static struct platform_driver ahci_driver = {

	.remove = __devexit_p(ahci_remove),

	.probe = ahci_probe,

	.remove = ata_platform_remove_one,

	.driver = {

		.name = "ahci",

		.owner = THIS_MODULE,
@@ -335,18 +342,7 @@ static struct platform_driver ahci_driver = { 
	},

	.id_table	= ahci_devtype,

};



static int __init ahci_init(void)

{

	return platform_driver_probe(&ahci_driver, ahci_probe);

}

module_init(ahci_init);



static void __exit ahci_exit(void)

{

	platform_driver_unregister(&ahci_driver);

}

module_exit(ahci_exit);

module_platform_driver(ahci_driver);



MODULE_DESCRIPTION("AHCI SATA platform driver");

MODULE_AUTHOR("Anton Vorontsov <avorontsov@ru.mvista.com>");

drivers/ata/ata_piix.c

+220 −224
Original line number Diff line number Diff line
@@ -164,28 +164,6 @@ struct piix_host_priv { 
	void __iomem *sidpr;

};



static int piix_init_one(struct pci_dev *pdev,

			 const struct pci_device_id *ent);

static void piix_remove_one(struct pci_dev *pdev);

static int piix_pata_prereset(struct ata_link *link, unsigned long deadline);

static void piix_set_piomode(struct ata_port *ap, struct ata_device *adev);

static void piix_set_dmamode(struct ata_port *ap, struct ata_device *adev);

static void ich_set_dmamode(struct ata_port *ap, struct ata_device *adev);

static int ich_pata_cable_detect(struct ata_port *ap);

static u8 piix_vmw_bmdma_status(struct ata_port *ap);

static int piix_sidpr_scr_read(struct ata_link *link,

			       unsigned int reg, u32 *val);

static int piix_sidpr_scr_write(struct ata_link *link,

				unsigned int reg, u32 val);

static int piix_sidpr_set_lpm(struct ata_link *link, enum ata_lpm_policy policy,

			      unsigned hints);

static bool piix_irq_check(struct ata_port *ap);

static int piix_port_start(struct ata_port *ap);

#ifdef CONFIG_PM

static int piix_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg);

static int piix_pci_device_resume(struct pci_dev *pdev);

#endif



static unsigned int in_module_init = 1;



static const struct pci_device_id piix_pci_tbl[] = {
@@ -342,64 +320,6 @@ static const struct pci_device_id piix_pci_tbl[] = { 
	{ }	/* terminate list */

};



static struct pci_driver piix_pci_driver = {

	.name			= DRV_NAME,

	.id_table		= piix_pci_tbl,

	.probe			= piix_init_one,

	.remove			= piix_remove_one,

#ifdef CONFIG_PM

	.suspend		= piix_pci_device_suspend,

	.resume			= piix_pci_device_resume,

#endif

};



static struct scsi_host_template piix_sht = {

	ATA_BMDMA_SHT(DRV_NAME),

};



static struct ata_port_operations piix_sata_ops = {

	.inherits		= &ata_bmdma32_port_ops,

	.sff_irq_check		= piix_irq_check,

	.port_start		= piix_port_start,

};



static struct ata_port_operations piix_pata_ops = {

	.inherits		= &piix_sata_ops,

	.cable_detect		= ata_cable_40wire,

	.set_piomode		= piix_set_piomode,

	.set_dmamode		= piix_set_dmamode,

	.prereset		= piix_pata_prereset,

};



static struct ata_port_operations piix_vmw_ops = {

	.inherits		= &piix_pata_ops,

	.bmdma_status		= piix_vmw_bmdma_status,

};



static struct ata_port_operations ich_pata_ops = {

	.inherits		= &piix_pata_ops,

	.cable_detect		= ich_pata_cable_detect,

	.set_dmamode		= ich_set_dmamode,

};



static struct device_attribute *piix_sidpr_shost_attrs[] = {

	&dev_attr_link_power_management_policy,

	NULL

};



static struct scsi_host_template piix_sidpr_sht = {

	ATA_BMDMA_SHT(DRV_NAME),

	.shost_attrs		= piix_sidpr_shost_attrs,

};



static struct ata_port_operations piix_sidpr_sata_ops = {

	.inherits		= &piix_sata_ops,

	.hardreset		= sata_std_hardreset,

	.scr_read		= piix_sidpr_scr_read,

	.scr_write		= piix_sidpr_scr_write,

	.set_lpm		= piix_sidpr_set_lpm,

};



static const struct piix_map_db ich5_map_db = {

	.mask = 0x7,

	.port_enable = 0x3,
@@ -504,147 +424,6 @@ static const struct piix_map_db *piix_map_db_table[] = { 
	[ich8_sata_snb]		= &ich8_map_db,

};



static struct ata_port_info piix_port_info[] = {

	[piix_pata_mwdma] = 	/* PIIX3 MWDMA only */

	{

		.flags		= PIIX_PATA_FLAGS,

		.pio_mask	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA12_ONLY, /* mwdma1-2 ?? CHECK 0 should be ok but slow */

		.port_ops	= &piix_pata_ops,

	},



	[piix_pata_33] =	/* PIIX4 at 33MHz */

	{

		.flags		= PIIX_PATA_FLAGS,

		.pio_mask	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA12_ONLY, /* mwdma1-2 ?? CHECK 0 should be ok but slow */

		.udma_mask	= ATA_UDMA2,

		.port_ops	= &piix_pata_ops,

	},



	[ich_pata_33] = 	/* ICH0 - ICH at 33Mhz*/

	{

		.flags		= PIIX_PATA_FLAGS,

		.pio_mask 	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA12_ONLY, /* Check: maybe MWDMA0 is ok  */

		.udma_mask	= ATA_UDMA2,

		.port_ops	= &ich_pata_ops,

	},



	[ich_pata_66] = 	/* ICH controllers up to 66MHz */

	{

		.flags		= PIIX_PATA_FLAGS,

		.pio_mask 	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA12_ONLY, /* MWDMA0 is broken on chip */

		.udma_mask	= ATA_UDMA4,

		.port_ops	= &ich_pata_ops,

	},



	[ich_pata_100] =

	{

		.flags		= PIIX_PATA_FLAGS | PIIX_FLAG_CHECKINTR,

		.pio_mask	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA12_ONLY,

		.udma_mask	= ATA_UDMA5,

		.port_ops	= &ich_pata_ops,

	},



	[ich_pata_100_nomwdma1] =

	{

		.flags		= PIIX_PATA_FLAGS | PIIX_FLAG_CHECKINTR,

		.pio_mask	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA2_ONLY,

		.udma_mask	= ATA_UDMA5,

		.port_ops	= &ich_pata_ops,

	},



	[ich5_sata] =

	{

		.flags		= PIIX_SATA_FLAGS,

		.pio_mask	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA2,

		.udma_mask	= ATA_UDMA6,

		.port_ops	= &piix_sata_ops,

	},



	[ich6_sata] =

	{

		.flags		= PIIX_SATA_FLAGS,

		.pio_mask	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA2,

		.udma_mask	= ATA_UDMA6,

		.port_ops	= &piix_sata_ops,

	},



	[ich6m_sata] =

	{

		.flags		= PIIX_SATA_FLAGS,

		.pio_mask	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA2,

		.udma_mask	= ATA_UDMA6,

		.port_ops	= &piix_sata_ops,

	},



	[ich8_sata] =

	{

		.flags		= PIIX_SATA_FLAGS | PIIX_FLAG_SIDPR,

		.pio_mask	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA2,

		.udma_mask	= ATA_UDMA6,

		.port_ops	= &piix_sata_ops,

	},



	[ich8_2port_sata] =

	{

		.flags		= PIIX_SATA_FLAGS | PIIX_FLAG_SIDPR,

		.pio_mask	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA2,

		.udma_mask	= ATA_UDMA6,

		.port_ops	= &piix_sata_ops,

	},



	[tolapai_sata] =

	{

		.flags		= PIIX_SATA_FLAGS,

		.pio_mask	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA2,

		.udma_mask	= ATA_UDMA6,

		.port_ops	= &piix_sata_ops,

	},



	[ich8m_apple_sata] =

	{

		.flags		= PIIX_SATA_FLAGS,

		.pio_mask	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA2,

		.udma_mask	= ATA_UDMA6,

		.port_ops	= &piix_sata_ops,

	},



	[piix_pata_vmw] =

	{

		.flags		= PIIX_PATA_FLAGS,

		.pio_mask	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA12_ONLY, /* mwdma1-2 ?? CHECK 0 should be ok but slow */

		.udma_mask	= ATA_UDMA2,

		.port_ops	= &piix_vmw_ops,

	},



	/*

	 * some Sandybridge chipsets have broken 32 mode up to now,

	 * see https://bugzilla.kernel.org/show_bug.cgi?id=40592

	 */

	[ich8_sata_snb] =

	{

		.flags		= PIIX_SATA_FLAGS | PIIX_FLAG_SIDPR | PIIX_FLAG_PIO16,

		.pio_mask	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA2,

		.udma_mask	= ATA_UDMA6,

		.port_ops	= &piix_sata_ops,

	},



};



static struct pci_bits piix_enable_bits[] = {

	{ 0x41U, 1U, 0x80UL, 0x80UL },	/* port 0 */

	{ 0x43U, 1U, 0x80UL, 0x80UL },	/* port 1 */
@@ -1261,6 +1040,193 @@ static u8 piix_vmw_bmdma_status(struct ata_port *ap) 
	return ata_bmdma_status(ap) & ~ATA_DMA_ERR;

}



static struct scsi_host_template piix_sht = {

	ATA_BMDMA_SHT(DRV_NAME),

};



static struct ata_port_operations piix_sata_ops = {

	.inherits		= &ata_bmdma32_port_ops,

	.sff_irq_check		= piix_irq_check,

	.port_start		= piix_port_start,

};



static struct ata_port_operations piix_pata_ops = {

	.inherits		= &piix_sata_ops,

	.cable_detect		= ata_cable_40wire,

	.set_piomode		= piix_set_piomode,

	.set_dmamode		= piix_set_dmamode,

	.prereset		= piix_pata_prereset,

};



static struct ata_port_operations piix_vmw_ops = {

	.inherits		= &piix_pata_ops,

	.bmdma_status		= piix_vmw_bmdma_status,

};



static struct ata_port_operations ich_pata_ops = {

	.inherits		= &piix_pata_ops,

	.cable_detect		= ich_pata_cable_detect,

	.set_dmamode		= ich_set_dmamode,

};



static struct device_attribute *piix_sidpr_shost_attrs[] = {

	&dev_attr_link_power_management_policy,

	NULL

};



static struct scsi_host_template piix_sidpr_sht = {

	ATA_BMDMA_SHT(DRV_NAME),

	.shost_attrs		= piix_sidpr_shost_attrs,

};



static struct ata_port_operations piix_sidpr_sata_ops = {

	.inherits		= &piix_sata_ops,

	.hardreset		= sata_std_hardreset,

	.scr_read		= piix_sidpr_scr_read,

	.scr_write		= piix_sidpr_scr_write,

	.set_lpm		= piix_sidpr_set_lpm,

};



static struct ata_port_info piix_port_info[] = {

	[piix_pata_mwdma] =	/* PIIX3 MWDMA only */

	{

		.flags		= PIIX_PATA_FLAGS,

		.pio_mask	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA12_ONLY, /* mwdma1-2 ?? CHECK 0 should be ok but slow */

		.port_ops	= &piix_pata_ops,

	},



	[piix_pata_33] =	/* PIIX4 at 33MHz */

	{

		.flags		= PIIX_PATA_FLAGS,

		.pio_mask	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA12_ONLY, /* mwdma1-2 ?? CHECK 0 should be ok but slow */

		.udma_mask	= ATA_UDMA2,

		.port_ops	= &piix_pata_ops,

	},



	[ich_pata_33] =		/* ICH0 - ICH at 33Mhz*/

	{

		.flags		= PIIX_PATA_FLAGS,

		.pio_mask	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA12_ONLY, /* Check: maybe MWDMA0 is ok  */

		.udma_mask	= ATA_UDMA2,

		.port_ops	= &ich_pata_ops,

	},



	[ich_pata_66] =		/* ICH controllers up to 66MHz */

	{

		.flags		= PIIX_PATA_FLAGS,

		.pio_mask	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA12_ONLY, /* MWDMA0 is broken on chip */

		.udma_mask	= ATA_UDMA4,

		.port_ops	= &ich_pata_ops,

	},



	[ich_pata_100] =

	{

		.flags		= PIIX_PATA_FLAGS | PIIX_FLAG_CHECKINTR,

		.pio_mask	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA12_ONLY,

		.udma_mask	= ATA_UDMA5,

		.port_ops	= &ich_pata_ops,

	},



	[ich_pata_100_nomwdma1] =

	{

		.flags		= PIIX_PATA_FLAGS | PIIX_FLAG_CHECKINTR,

		.pio_mask	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA2_ONLY,

		.udma_mask	= ATA_UDMA5,

		.port_ops	= &ich_pata_ops,

	},



	[ich5_sata] =

	{

		.flags		= PIIX_SATA_FLAGS,

		.pio_mask	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA2,

		.udma_mask	= ATA_UDMA6,

		.port_ops	= &piix_sata_ops,

	},



	[ich6_sata] =

	{

		.flags		= PIIX_SATA_FLAGS,

		.pio_mask	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA2,

		.udma_mask	= ATA_UDMA6,

		.port_ops	= &piix_sata_ops,

	},



	[ich6m_sata] =

	{

		.flags		= PIIX_SATA_FLAGS,

		.pio_mask	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA2,

		.udma_mask	= ATA_UDMA6,

		.port_ops	= &piix_sata_ops,

	},



	[ich8_sata] =

	{

		.flags		= PIIX_SATA_FLAGS | PIIX_FLAG_SIDPR,

		.pio_mask	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA2,

		.udma_mask	= ATA_UDMA6,

		.port_ops	= &piix_sata_ops,

	},



	[ich8_2port_sata] =

	{

		.flags		= PIIX_SATA_FLAGS | PIIX_FLAG_SIDPR,

		.pio_mask	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA2,

		.udma_mask	= ATA_UDMA6,

		.port_ops	= &piix_sata_ops,

	},



	[tolapai_sata] =

	{

		.flags		= PIIX_SATA_FLAGS,

		.pio_mask	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA2,

		.udma_mask	= ATA_UDMA6,

		.port_ops	= &piix_sata_ops,

	},



	[ich8m_apple_sata] =

	{

		.flags		= PIIX_SATA_FLAGS,

		.pio_mask	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA2,

		.udma_mask	= ATA_UDMA6,

		.port_ops	= &piix_sata_ops,

	},



	[piix_pata_vmw] =

	{

		.flags		= PIIX_PATA_FLAGS,

		.pio_mask	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA12_ONLY, /* mwdma1-2 ?? CHECK 0 should be ok but slow */

		.udma_mask	= ATA_UDMA2,

		.port_ops	= &piix_vmw_ops,

	},



	/*

	 * some Sandybridge chipsets have broken 32 mode up to now,

	 * see https://bugzilla.kernel.org/show_bug.cgi?id=40592

	 */

	[ich8_sata_snb] =

	{

		.flags		= PIIX_SATA_FLAGS | PIIX_FLAG_SIDPR | PIIX_FLAG_PIO16,

		.pio_mask	= ATA_PIO4,

		.mwdma_mask	= ATA_MWDMA2,

		.udma_mask	= ATA_UDMA6,

		.port_ops	= &piix_sata_ops,

	},

};



#define AHCI_PCI_BAR 5

#define AHCI_GLOBAL_CTL 0x04

#define AHCI_ENABLE (1 << 31)
@@ -1585,12 +1551,31 @@ static void piix_ignore_devices_quirk(struct ata_host *host) 
		},

		{ }	/* terminate list */

	};

	const struct dmi_system_id *dmi = dmi_first_match(ignore_hyperv);

	static const struct dmi_system_id allow_virtual_pc[] = {

		{

			/* In MS Virtual PC guests the DMI ident is nearly

			 * identical to a Hyper-V guest. One difference is the

			 * product version which is used here to identify

			 * a Virtual PC guest. This entry allows ata_piix to

			 * drive the emulated hardware.

			 */

			.ident = "MS Virtual PC 2007",

			.matches = {

				DMI_MATCH(DMI_SYS_VENDOR,

						"Microsoft Corporation"),

				DMI_MATCH(DMI_PRODUCT_NAME, "Virtual Machine"),

				DMI_MATCH(DMI_PRODUCT_VERSION, "VS2005R2"),

			},

		},

		{ }	/* terminate list */

	};

	const struct dmi_system_id *ignore = dmi_first_match(ignore_hyperv);

	const struct dmi_system_id *allow = dmi_first_match(allow_virtual_pc);



	if (dmi && prefer_ms_hyperv) {

	if (ignore && !allow && prefer_ms_hyperv) {

		host->flags |= ATA_HOST_IGNORE_ATA;

		dev_info(host->dev, "%s detected, ATA device ignore set\n",

			dmi->ident);

			ignore->ident);

	}

#endif

}
@@ -1727,6 +1712,17 @@ static void piix_remove_one(struct pci_dev *pdev) 
	ata_pci_remove_one(pdev);

}



static struct pci_driver piix_pci_driver = {

	.name			= DRV_NAME,

	.id_table		= piix_pci_tbl,

	.probe			= piix_init_one,

	.remove			= piix_remove_one,

#ifdef CONFIG_PM

	.suspend		= piix_pci_device_suspend,

	.resume			= piix_pci_device_resume,

#endif

};



static int __init piix_init(void)

{

	int rc;

drivers/ata/libahci.c

+1 −1
Original line number Diff line number Diff line
@@ -1384,7 +1384,7 @@ int ahci_pmp_retry_softreset(struct ata_link *link, unsigned int *class, 
	if (rc == -EIO) {

		irq_sts = readl(port_mmio + PORT_IRQ_STAT);

		if (irq_sts & PORT_IRQ_BAD_PMP) {

			ata_link_printk(link, KERN_WARNING,

			ata_link_warn(link,

					"applying PMP SRST workaround "

					"and retrying\n");

			rc = ahci_do_softreset(link, class, 0, deadline,

drivers/ata/libata-acpi.c

+4 −0
Original line number Diff line number Diff line
@@ -76,6 +76,9 @@ acpi_handle ata_dev_acpi_handle(struct ata_device *dev) 
	acpi_integer adr;

	struct ata_port *ap = dev->link->ap;



	if (dev->flags & ATA_DFLAG_ACPI_DISABLED)

		return NULL;



	if (ap->flags & ATA_FLAG_ACPI_SATA) {

		if (!sata_pmp_attached(ap))

			adr = SATA_ADR(ap->port_no, NO_PORT_MULT);
@@ -945,6 +948,7 @@ int ata_acpi_on_devcfg(struct ata_device *dev) 
		return rc;

	}



	dev->flags |= ATA_DFLAG_ACPI_DISABLED;

	ata_dev_warn(dev, "ACPI: failed the second time, disabled\n");



	/* We can safely continue if no _GTF command has been executed

drivers/ata/libata-core.c

+27 −4
Original line number Diff line number Diff line
@@ -67,6 +67,7 @@ 
#include <linux/cdrom.h>

#include <linux/ratelimit.h>

#include <linux/pm_runtime.h>

#include <linux/platform_device.h>



#include "libata.h"

#include "libata-transport.h"
@@ -2560,6 +2561,7 @@ int ata_bus_probe(struct ata_port *ap) 
		 * bus as we may be talking too fast.

		 */

		dev->pio_mode = XFER_PIO_0;

		dev->dma_mode = 0xff;



		/* If the controller has a pio mode setup function

		 * then use it to set the chipset to rights. Don't
@@ -6286,8 +6288,7 @@ void ata_host_detach(struct ata_host *host) 
 */

void ata_pci_remove_one(struct pci_dev *pdev)

{

	struct device *dev = &pdev->dev;

	struct ata_host *host = dev_get_drvdata(dev);

	struct ata_host *host = pci_get_drvdata(pdev);



	ata_host_detach(host);

}
@@ -6356,7 +6357,7 @@ int ata_pci_device_do_resume(struct pci_dev *pdev) 


int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg)

{

	struct ata_host *host = dev_get_drvdata(&pdev->dev);

	struct ata_host *host = pci_get_drvdata(pdev);

	int rc = 0;



	rc = ata_host_suspend(host, mesg);
@@ -6370,7 +6371,7 @@ int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg) 


int ata_pci_device_resume(struct pci_dev *pdev)

{

	struct ata_host *host = dev_get_drvdata(&pdev->dev);

	struct ata_host *host = pci_get_drvdata(pdev);

	int rc;



	rc = ata_pci_device_do_resume(pdev);
@@ -6382,6 +6383,26 @@ int ata_pci_device_resume(struct pci_dev *pdev) 


#endif /* CONFIG_PCI */



/**

 *	ata_platform_remove_one - Platform layer callback for device removal

 *	@pdev: Platform device that was removed

 *

 *	Platform layer indicates to libata via this hook that hot-unplug or

 *	module unload event has occurred.  Detach all ports.  Resource

 *	release is handled via devres.

 *

 *	LOCKING:

 *	Inherited from platform layer (may sleep).

 */

int ata_platform_remove_one(struct platform_device *pdev)

{

	struct ata_host *host = platform_get_drvdata(pdev);



	ata_host_detach(host);



	return 0;

}



static int __init ata_parse_force_one(char **cur,

				      struct ata_force_ent *force_ent,

				      const char **reason)
@@ -6877,6 +6898,8 @@ EXPORT_SYMBOL_GPL(ata_pci_device_resume); 
#endif /* CONFIG_PM */

#endif /* CONFIG_PCI */



EXPORT_SYMBOL_GPL(ata_platform_remove_one);



EXPORT_SYMBOL_GPL(__ata_ehi_push_desc);

EXPORT_SYMBOL_GPL(ata_ehi_push_desc);

EXPORT_SYMBOL_GPL(ata_ehi_clear_desc);