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

drivers/ata/Kconfig

+9 −0

Original line number	Original line	Diff line number	Diff line
	@@ -468,6 +468,15 @@ config PATA_ICSIDE
	interface card. This is not required for ICS partition support.		interface card. This is not required for ICS partition support.
	If you are unsure, say N to this.		If you are unsure, say N to this.

			config PATA_IMX
			tristate "PATA support for Freescale iMX"
			depends on ARCH_MXC
			help
			This option enables support for the PATA host available on Freescale
			iMX SoCs.

			If unsure, say N.

	config PATA_IT8213		config PATA_IT8213
	tristate "IT8213 PATA support (Experimental)"		tristate "IT8213 PATA support (Experimental)"
	depends on PCI && EXPERIMENTAL		depends on PCI && EXPERIMENTAL

drivers/ata/Makefile

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -48,6 +48,7 @@ obj-$(CONFIG_PATA_HPT37X) += pata_hpt37x.o
	obj-$(CONFIG_PATA_HPT3X2N) += pata_hpt3x2n.o		obj-$(CONFIG_PATA_HPT3X2N) += pata_hpt3x2n.o
	obj-$(CONFIG_PATA_HPT3X3) += pata_hpt3x3.o		obj-$(CONFIG_PATA_HPT3X3) += pata_hpt3x3.o
	obj-$(CONFIG_PATA_ICSIDE) += pata_icside.o		obj-$(CONFIG_PATA_ICSIDE) += pata_icside.o
			obj-$(CONFIG_PATA_IMX) += pata_imx.o
	obj-$(CONFIG_PATA_IT8213) += pata_it8213.o		obj-$(CONFIG_PATA_IT8213) += pata_it8213.o
	obj-$(CONFIG_PATA_IT821X) += pata_it821x.o		obj-$(CONFIG_PATA_IT821X) += pata_it821x.o
	obj-$(CONFIG_PATA_JMICRON) += pata_jmicron.o		obj-$(CONFIG_PATA_JMICRON) += pata_jmicron.o

drivers/ata/pata_imx.c

0 → 100644

+253 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Freescale iMX PATA driver
			*
			* Copyright (C) 2011 Arnaud Patard <arnaud.patard@rtp-net.org>
			*
			* Based on pata_platform - Copyright (C) 2006 - 2007 Paul Mundt
			*
			* This file is subject to the terms and conditions of the GNU General Public
			* License. See the file "COPYING" in the main directory of this archive
			* for more details.
			*
			* TODO:
			* - dmaengine support
			* - check if timing stuff needed
			*/
			#include <linux/kernel.h>
			#include <linux/module.h>
			#include <linux/init.h>
			#include <linux/blkdev.h>
			#include <scsi/scsi_host.h>
			#include <linux/ata.h>
			#include <linux/libata.h>
			#include <linux/platform_device.h>
			#include <linux/clk.h>

			#define DRV_NAME "pata_imx"

			#define PATA_IMX_ATA_CONTROL 0x24
			#define PATA_IMX_ATA_CTRL_FIFO_RST_B (1<<7)
			#define PATA_IMX_ATA_CTRL_ATA_RST_B (1<<6)
			#define PATA_IMX_ATA_CTRL_IORDY_EN (1<<0)
			#define PATA_IMX_ATA_INT_EN 0x2C
			#define PATA_IMX_ATA_INTR_ATA_INTRQ2 (1<<3)
			#define PATA_IMX_DRIVE_DATA 0xA0
			#define PATA_IMX_DRIVE_CONTROL 0xD8

			struct pata_imx_priv {
			struct clk *clk;
			/* timings/interrupt/control regs */
			u8 *host_regs;
			u32 ata_ctl;
			};

			static int pata_imx_set_mode(struct ata_link link, struct ata_device *unused)
			{
			struct ata_device *dev;
			struct ata_port *ap = link->ap;
			struct pata_imx_priv *priv = ap->host->private_data;
			u32 val;

			ata_for_each_dev(dev, link, ENABLED) {
			dev->pio_mode = dev->xfer_mode = XFER_PIO_0;
			dev->xfer_shift = ATA_SHIFT_PIO;
			dev->flags \|= ATA_DFLAG_PIO;

			val = __raw_readl(priv->host_regs + PATA_IMX_ATA_CONTROL);
			if (ata_pio_need_iordy(dev))
			val \|= PATA_IMX_ATA_CTRL_IORDY_EN;
			else
			val &= ~PATA_IMX_ATA_CTRL_IORDY_EN;
			__raw_writel(val, priv->host_regs + PATA_IMX_ATA_CONTROL);

			ata_dev_printk(dev, KERN_INFO, "configured for PIO\n");
			}
			return 0;
			}

			static struct scsi_host_template pata_imx_sht = {
			ATA_PIO_SHT(DRV_NAME),
			};

			static struct ata_port_operations pata_imx_port_ops = {
			.inherits = &ata_sff_port_ops,
			.sff_data_xfer = ata_sff_data_xfer_noirq,
			.cable_detect = ata_cable_unknown,
			.set_mode = pata_imx_set_mode,
			};

			static void pata_imx_setup_port(struct ata_ioports *ioaddr)
			{
			/* Fixup the port shift for platforms that need it */
			ioaddr->data_addr = ioaddr->cmd_addr + (ATA_REG_DATA << 2);
			ioaddr->error_addr = ioaddr->cmd_addr + (ATA_REG_ERR << 2);
			ioaddr->feature_addr = ioaddr->cmd_addr + (ATA_REG_FEATURE << 2);
			ioaddr->nsect_addr = ioaddr->cmd_addr + (ATA_REG_NSECT << 2);
			ioaddr->lbal_addr = ioaddr->cmd_addr + (ATA_REG_LBAL << 2);
			ioaddr->lbam_addr = ioaddr->cmd_addr + (ATA_REG_LBAM << 2);
			ioaddr->lbah_addr = ioaddr->cmd_addr + (ATA_REG_LBAH << 2);
			ioaddr->device_addr = ioaddr->cmd_addr + (ATA_REG_DEVICE << 2);
			ioaddr->status_addr = ioaddr->cmd_addr + (ATA_REG_STATUS << 2);
			ioaddr->command_addr = ioaddr->cmd_addr + (ATA_REG_CMD << 2);
			}

			static int __devinit pata_imx_probe(struct platform_device *pdev)
			{
			struct ata_host *host;
			struct ata_port *ap;
			struct pata_imx_priv *priv;
			int irq = 0;
			struct resource *io_res;

			io_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
			if (io_res == NULL)
			return -EINVAL;

			irq = platform_get_irq(pdev, 0);
			if (irq <= 0)
			return -EINVAL;

			priv = devm_kzalloc(&pdev->dev,
			sizeof(struct pata_imx_priv), GFP_KERNEL);
			if (!priv)
			return -ENOMEM;

			priv->clk = clk_get(&pdev->dev, NULL);
			if (IS_ERR(priv->clk)) {
			dev_err(&pdev->dev, "Failed to get clock\n");
			return PTR_ERR(priv->clk);
			}

			clk_enable(priv->clk);

			host = ata_host_alloc(&pdev->dev, 1);
			if (!host)
			goto free_priv;

			host->private_data = priv;
			ap = host->ports[0];

			ap->ops = &pata_imx_port_ops;
			ap->pio_mask = ATA_PIO0;
			ap->flags \|= ATA_FLAG_SLAVE_POSS;

			priv->host_regs = devm_ioremap(&pdev->dev, io_res->start,
			resource_size(io_res));
			if (!priv->host_regs) {
			dev_err(&pdev->dev, "failed to map IO/CTL base\n");
			goto free_priv;
			}

			ap->ioaddr.cmd_addr = priv->host_regs + PATA_IMX_DRIVE_DATA;
			ap->ioaddr.ctl_addr = priv->host_regs + PATA_IMX_DRIVE_CONTROL;

			ap->ioaddr.altstatus_addr = ap->ioaddr.ctl_addr;

			pata_imx_setup_port(&ap->ioaddr);

			ata_port_desc(ap, "cmd 0x%llx ctl 0x%llx",
			(unsigned long long)io_res->start + PATA_IMX_DRIVE_DATA,
			(unsigned long long)io_res->start + PATA_IMX_DRIVE_CONTROL);

			/* deassert resets */
			__raw_writel(PATA_IMX_ATA_CTRL_FIFO_RST_B \|
			PATA_IMX_ATA_CTRL_ATA_RST_B,
			priv->host_regs + PATA_IMX_ATA_CONTROL);
			/* enable interrupts */
			__raw_writel(PATA_IMX_ATA_INTR_ATA_INTRQ2,
			priv->host_regs + PATA_IMX_ATA_INT_EN);

			/* activate */
			return ata_host_activate(host, irq, ata_sff_interrupt, 0,
			&pata_imx_sht);

			free_priv:
			clk_disable(priv->clk);
			clk_put(priv->clk);
			return -ENOMEM;
			}

			static int __devexit pata_imx_remove(struct platform_device *pdev)
			{
			struct ata_host *host = dev_get_drvdata(&pdev->dev);
			struct pata_imx_priv *priv = host->private_data;

			ata_host_detach(host);

			__raw_writel(0, priv->host_regs + PATA_IMX_ATA_INT_EN);

			clk_disable(priv->clk);
			clk_put(priv->clk);

			return 0;
			}

			#ifdef CONFIG_PM
			static int pata_imx_suspend(struct device *dev)
			{
			struct ata_host *host = dev_get_drvdata(dev);
			struct pata_imx_priv *priv = host->private_data;
			int ret;

			ret = ata_host_suspend(host, PMSG_SUSPEND);
			if (!ret) {
			__raw_writel(0, priv->host_regs + PATA_IMX_ATA_INT_EN);
			priv->ata_ctl =
			__raw_readl(priv->host_regs + PATA_IMX_ATA_CONTROL);
			clk_disable(priv->clk);
			}

			return ret;
			}

			static int pata_imx_resume(struct device *dev)
			{
			struct ata_host *host = dev_get_drvdata(dev);
			struct pata_imx_priv *priv = host->private_data;

			clk_enable(priv->clk);

			__raw_writel(priv->ata_ctl, priv->host_regs + PATA_IMX_ATA_CONTROL);

			__raw_writel(PATA_IMX_ATA_INTR_ATA_INTRQ2,
			priv->host_regs + PATA_IMX_ATA_INT_EN);

			ata_host_resume(host);

			return 0;
			}

			static const struct dev_pm_ops pata_imx_pm_ops = {
			.suspend = pata_imx_suspend,
			.resume = pata_imx_resume,
			};
			#endif

			static struct platform_driver pata_imx_driver = {
			.probe = pata_imx_probe,
			.remove = __devexit_p(pata_imx_remove),
			.driver = {
			.name = DRV_NAME,
			.owner = THIS_MODULE,
			#ifdef CONFIG_PM
			.pm = &pata_imx_pm_ops,
			#endif
			},
			};

			static int __init pata_imx_init(void)
			{
			return platform_driver_register(&pata_imx_driver);
			}

			static void __exit pata_imx_exit(void)
			{
			platform_driver_unregister(&pata_imx_driver);
			}
			module_init(pata_imx_init);
			module_exit(pata_imx_exit);

			MODULE_AUTHOR("Arnaud Patard <arnaud.patard@rtp-net.org>");
			MODULE_DESCRIPTION("low-level driver for iMX PATA");
			MODULE_LICENSE("GPL");
			MODULE_ALIAS("platform:" DRV_NAME);

drivers/ata/pata_via.c

+18 −0

Original line number	Original line	Diff line number	Diff line
	@@ -124,6 +124,17 @@ static const struct via_isa_bridge {
	{ NULL }		{ NULL }
	};		};

			static const struct dmi_system_id no_atapi_dma_dmi_table[] = {
			{
			.ident = "AVERATEC 3200",
			.matches = {
			DMI_MATCH(DMI_BOARD_VENDOR, "AVERATEC"),
			DMI_MATCH(DMI_BOARD_NAME, "3200"),
			},
			},
			{ }
			};

	struct via_port {		struct via_port {
	u8 cached_device;		u8 cached_device;
	};		};
	@@ -355,6 +366,13 @@ static unsigned long via_mode_filter(struct ata_device *dev, unsigned long mask)
	mask &= ~ ATA_MASK_UDMA;		mask &= ~ ATA_MASK_UDMA;
	}		}
	}		}

			if (dev->class == ATA_DEV_ATAPI &&
			dmi_check_system(no_atapi_dma_dmi_table)) {
			ata_dev_warn(dev, "controller locks up on ATAPI DMA, forcing PIO\n");
			mask &= ATA_MASK_PIO;
			}

	return mask;		return mask;
	}		}

drivers/ata/sata_dwc_460ex.c

+6 −8

Original line number	Original line	Diff line number	Diff line
	@@ -1329,7 +1329,7 @@ static int sata_dwc_port_start(struct ata_port *ap)
	dev_err(ap->dev, "%s: dma_alloc_coherent failed\n",		dev_err(ap->dev, "%s: dma_alloc_coherent failed\n",
	__func__);		__func__);
	err = -ENOMEM;		err = -ENOMEM;
	goto CLEANUP;		goto CLEANUP_ALLOC;
	}		}
	}		}

	@@ -1349,15 +1349,13 @@ static int sata_dwc_port_start(struct ata_port *ap)
	/* Clear any error bits before libata starts issuing commands */		/* Clear any error bits before libata starts issuing commands */
	clear_serror();		clear_serror();
	ap->private_data = hsdevp;		ap->private_data = hsdevp;

	CLEANUP:
	if (err) {
	sata_dwc_port_stop(ap);
	dev_dbg(ap->dev, "%s: fail\n", __func__);
	} else {
	dev_dbg(ap->dev, "%s: done\n", __func__);		dev_dbg(ap->dev, "%s: done\n", __func__);
	}		return 0;

			CLEANUP_ALLOC:
			kfree(hsdevp);
			CLEANUP:
			dev_dbg(ap->dev, "%s: fail. ap->id = %d\n", __func__, ap->print_id);
	return err;		return err;
	}		}

Admin message