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

drivers/ata/ahci.c

+8 −2

Original line number	Diff line number	Diff line
		@@ -105,7 +105,7 @@ enum {
		board_ahci_ign_iferr = 2,
		board_ahci_sb600 = 3,
		board_ahci_mv = 4,
		board_ahci_sb700 = 5,
		board_ahci_sb700 = 5, /* for SB700 and SB800 */
		board_ahci_mcp65 = 6,
		board_ahci_nopmp = 7,

		@@ -439,7 +439,7 @@ static const struct ata_port_info ahci_port_info[] = {
		.udma_mask = ATA_UDMA6,
		.port_ops = &ahci_ops,
		},
		/* board_ahci_sb700 */
		/* board_ahci_sb700, for SB700 and SB800 */
		{
		AHCI_HFLAGS (AHCI_HFLAG_IGN_SERR_INTERNAL),
		.flags = AHCI_FLAG_COMMON,
		@@ -2446,6 +2446,8 @@ static void ahci_print_info(struct ata_host *host)
		speed_s = "1.5";
		else if (speed == 2)
		speed_s = "3";
		else if (speed == 3)
		speed_s = "6";
		else
		speed_s = "?";

		@@ -2610,6 +2612,10 @@ static int ahci_init_one(struct pci_dev pdev, const struct pci_device_id ent)
		(pdev->revision == 0xa1 \|\| pdev->revision == 0xa2))
		hpriv->flags \|= AHCI_HFLAG_NO_MSI;

		/* SB800 does NOT need the workaround to ignore SERR_INTERNAL */
		if (board_id == board_ahci_sb700 && pdev->revision >= 0x40)
		hpriv->flags &= ~AHCI_HFLAG_IGN_SERR_INTERNAL;

		if ((hpriv->flags & AHCI_HFLAG_NO_MSI) \|\| pci_enable_msi(pdev))
		pci_intx(pdev, 1);

drivers/ata/ata_piix.c

+35 −16

Original line number	Diff line number	Diff line
		@@ -154,11 +154,13 @@ struct piix_map_db {

		struct piix_host_priv {
		const int *map;
		u32 saved_iocfg;
		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);
		@@ -296,7 +298,7 @@ static struct pci_driver piix_pci_driver = {
		.name = DRV_NAME,
		.id_table = piix_pci_tbl,
		.probe = piix_init_one,
		.remove = ata_pci_remove_one,
		.remove = piix_remove_one,
		#ifdef CONFIG_PM
		.suspend = piix_pci_device_suspend,
		.resume = piix_pci_device_resume,
		@@ -308,7 +310,7 @@ static struct scsi_host_template piix_sht = {
		};

		static struct ata_port_operations piix_pata_ops = {
		.inherits = &ata_bmdma_port_ops,
		.inherits = &ata_bmdma32_port_ops,
		.cable_detect = ata_cable_40wire,
		.set_piomode = piix_set_piomode,
		.set_dmamode = piix_set_dmamode,
		@@ -610,8 +612,9 @@ static const struct ich_laptop ich_laptop[] = {
		static int ich_pata_cable_detect(struct ata_port *ap)
		{
		struct pci_dev *pdev = to_pci_dev(ap->host->dev);
		struct piix_host_priv *hpriv = ap->host->private_data;
		const struct ich_laptop *lap = &ich_laptop[0];
		u8 tmp, mask;
		u8 mask;

		/* Check for specials - Acer Aspire 5602WLMi */
		while (lap->device) {
		@@ -625,8 +628,7 @@ static int ich_pata_cable_detect(struct ata_port *ap)

		/* check BIOS cable detect results */
		mask = ap->port_no == 0 ? PIIX_80C_PRI : PIIX_80C_SEC;
		pci_read_config_byte(pdev, PIIX_IOCFG, &tmp);
		if ((tmp & mask) == 0)
		if ((hpriv->saved_iocfg & mask) == 0)
		return ATA_CBL_PATA40;
		return ATA_CBL_PATA80;
		}
		@@ -1350,7 +1352,7 @@ static int __devinit piix_init_sidpr(struct ata_host *host)
		return 0;
		}

		static void piix_iocfg_bit18_quirk(struct pci_dev *pdev)
		static void piix_iocfg_bit18_quirk(struct ata_host *host)
		{
		static const struct dmi_system_id sysids[] = {
		{
		@@ -1367,7 +1369,8 @@ static void piix_iocfg_bit18_quirk(struct pci_dev *pdev)

		{ } /* terminate list */
		};
		u32 iocfg;
		struct pci_dev *pdev = to_pci_dev(host->dev);
		struct piix_host_priv *hpriv = host->private_data;

		if (!dmi_check_system(sysids))
		return;
		@@ -1376,12 +1379,11 @@ static void piix_iocfg_bit18_quirk(struct pci_dev *pdev)
		* seem to use it to disable a channel. Clear the bit on the
		* affected systems.
		*/
		pci_read_config_dword(pdev, PIIX_IOCFG, &iocfg);
		if (iocfg & (1 << 18)) {
		if (hpriv->saved_iocfg & (1 << 18)) {
		dev_printk(KERN_INFO, &pdev->dev,
		"applying IOCFG bit18 quirk\n");
		iocfg &= ~(1 << 18);
		pci_write_config_dword(pdev, PIIX_IOCFG, iocfg);
		pci_write_config_dword(pdev, PIIX_IOCFG,
		hpriv->saved_iocfg & ~(1 << 18));
		}
		}

		@@ -1430,6 +1432,17 @@ static int __devinit piix_init_one(struct pci_dev *pdev,
		if (rc)
		return rc;

		hpriv = devm_kzalloc(dev, sizeof(*hpriv), GFP_KERNEL);
		if (!hpriv)
		return -ENOMEM;

		/* Save IOCFG, this will be used for cable detection, quirk
		* detection and restoration on detach. This is necessary
		* because some ACPI implementations mess up cable related
		* bits on _STM. Reported on kernel bz#11879.
		*/
		pci_read_config_dword(pdev, PIIX_IOCFG, &hpriv->saved_iocfg);

		/* ICH6R may be driven by either ata_piix or ahci driver
		* regardless of BIOS configuration. Make sure AHCI mode is
		* off.
		@@ -1441,10 +1454,6 @@ static int __devinit piix_init_one(struct pci_dev *pdev,
		}

		/* SATA map init can change port_info, do it before prepping host */
		hpriv = devm_kzalloc(dev, sizeof(*hpriv), GFP_KERNEL);
		if (!hpriv)
		return -ENOMEM;

		if (port_flags & ATA_FLAG_SATA)
		hpriv->map = piix_init_sata_map(pdev, port_info,
		piix_map_db_table[ent->driver_data]);
		@@ -1463,7 +1472,7 @@ static int __devinit piix_init_one(struct pci_dev *pdev,
		}

		/* apply IOCFG bit18 quirk */
		piix_iocfg_bit18_quirk(pdev);
		piix_iocfg_bit18_quirk(host);

		/* On ICH5, some BIOSen disable the interrupt using the
		* PCI_COMMAND_INTX_DISABLE bit added in PCI 2.3.
		@@ -1488,6 +1497,16 @@ static int __devinit piix_init_one(struct pci_dev *pdev,
		return ata_pci_sff_activate_host(host, ata_sff_interrupt, &piix_sht);
		}

		static void piix_remove_one(struct pci_dev *pdev)
		{
		struct ata_host *host = dev_get_drvdata(&pdev->dev);
		struct piix_host_priv *hpriv = host->private_data;

		pci_write_config_dword(pdev, PIIX_IOCFG, hpriv->saved_iocfg);

		ata_pci_remove_one(pdev);
		}

		static int __init piix_init(void)
		{
		int rc;

drivers/ata/libata-core.c

+5 −0

Original line number	Diff line number	Diff line
		@@ -1007,6 +1007,7 @@ static const char *sata_spd_string(unsigned int spd)
		static const char * const spd_str[] = {
		"1.5 Gbps",
		"3.0 Gbps",
		"6.0 Gbps",
		};

		if (spd == 0 \|\| (spd - 1) >= ARRAY_SIZE(spd_str))
		@@ -2000,6 +2001,10 @@ unsigned int ata_pio_need_iordy(const struct ata_device *adev)
		as the caller should know this */
		if (adev->link->ap->flags & ATA_FLAG_NO_IORDY)
		return 0;
		/* CF spec. r4.1 Table 22 says no iordy on PIO5 and PIO6. */
		if (ata_id_is_cfa(adev->id)
		&& (adev->pio_mode == XFER_PIO_5 \|\| adev->pio_mode == XFER_PIO_6))
		return 0;
		/* PIO3 and higher it is mandatory */
		if (adev->pio_mode > XFER_PIO_2)
		return 1;

drivers/ata/libata-sff.c

+120 −65

Original line number	Diff line number	Diff line
		@@ -66,6 +66,7 @@ const struct ata_port_operations ata_sff_port_ops = {

		.port_start = ata_sff_port_start,
		};
		EXPORT_SYMBOL_GPL(ata_sff_port_ops);

		const struct ata_port_operations ata_bmdma_port_ops = {
		.inherits = &ata_sff_port_ops,
		@@ -77,6 +78,14 @@ const struct ata_port_operations ata_bmdma_port_ops = {
		.bmdma_stop = ata_bmdma_stop,
		.bmdma_status = ata_bmdma_status,
		};
		EXPORT_SYMBOL_GPL(ata_bmdma_port_ops);

		const struct ata_port_operations ata_bmdma32_port_ops = {
		.inherits = &ata_bmdma_port_ops,

		.sff_data_xfer = ata_sff_data_xfer32,
		};
		EXPORT_SYMBOL_GPL(ata_bmdma32_port_ops);

		/**
		* ata_fill_sg - Fill PCI IDE PRD table
		@@ -167,7 +176,8 @@ static void ata_fill_sg_dumb(struct ata_queued_cmd *qc)
		ap->prd[pi].addr = cpu_to_le32(addr);
		if (blen == 0) {
		/* Some PATA chipsets like the CS5530 can't
		cope with 0x0000 meaning 64K as the spec says */
		cope with 0x0000 meaning 64K as the spec
		says */
		ap->prd[pi].flags_len = cpu_to_le32(0x8000);
		blen = 0x8000;
		ap->prd[++pi].addr = cpu_to_le32(addr + 0x8000);
		@@ -200,6 +210,7 @@ void ata_sff_qc_prep(struct ata_queued_cmd *qc)

		ata_fill_sg(qc);
		}
		EXPORT_SYMBOL_GPL(ata_sff_qc_prep);

		/**
		* ata_sff_dumb_qc_prep - Prepare taskfile for submission
		@@ -217,6 +228,7 @@ void ata_sff_dumb_qc_prep(struct ata_queued_cmd *qc)

		ata_fill_sg_dumb(qc);
		}
		EXPORT_SYMBOL_GPL(ata_sff_dumb_qc_prep);

		/**
		* ata_sff_check_status - Read device status reg & clear interrupt
		@@ -233,6 +245,7 @@ u8 ata_sff_check_status(struct ata_port *ap)
		{
		return ioread8(ap->ioaddr.status_addr);
		}
		EXPORT_SYMBOL_GPL(ata_sff_check_status);

		/**
		* ata_sff_altstatus - Read device alternate status reg
		@@ -319,6 +332,7 @@ void ata_sff_pause(struct ata_port *ap)
		ata_sff_sync(ap);
		ndelay(400);
		}
		EXPORT_SYMBOL_GPL(ata_sff_pause);

		/**
		* ata_sff_dma_pause - Pause before commencing DMA
		@@ -341,6 +355,7 @@ void ata_sff_dma_pause(struct ata_port *ap)
		corruption. */
		BUG();
		}
		EXPORT_SYMBOL_GPL(ata_sff_dma_pause);

		/**
		* ata_sff_busy_sleep - sleep until BSY clears, or timeout
		@@ -396,6 +411,7 @@ int ata_sff_busy_sleep(struct ata_port *ap,

		return 0;
		}
		EXPORT_SYMBOL_GPL(ata_sff_busy_sleep);

		static int ata_sff_check_ready(struct ata_link *link)
		{
		@@ -422,6 +438,7 @@ int ata_sff_wait_ready(struct ata_link *link, unsigned long deadline)
		{
		return ata_wait_ready(link, deadline, ata_sff_check_ready);
		}
		EXPORT_SYMBOL_GPL(ata_sff_wait_ready);

		/**
		* ata_sff_dev_select - Select device 0/1 on ATA bus
		@@ -449,6 +466,7 @@ void ata_sff_dev_select(struct ata_port *ap, unsigned int device)
		iowrite8(tmp, ap->ioaddr.device_addr);
		ata_sff_pause(ap); /* needed; also flushes, for mmio */
		}
		EXPORT_SYMBOL_GPL(ata_sff_dev_select);

		/**
		* ata_dev_select - Select device 0/1 on ATA bus
		@@ -513,6 +531,7 @@ u8 ata_sff_irq_on(struct ata_port *ap)

		return tmp;
		}
		EXPORT_SYMBOL_GPL(ata_sff_irq_on);

		/**
		* ata_sff_irq_clear - Clear PCI IDE BMDMA interrupt.
		@@ -534,6 +553,7 @@ void ata_sff_irq_clear(struct ata_port *ap)

		iowrite8(ioread8(mmio + ATA_DMA_STATUS), mmio + ATA_DMA_STATUS);
		}
		EXPORT_SYMBOL_GPL(ata_sff_irq_clear);

		/**
		* ata_sff_tf_load - send taskfile registers to host controller
		@@ -593,6 +613,7 @@ void ata_sff_tf_load(struct ata_port ap, const struct ata_taskfile tf)

		ata_wait_idle(ap);
		}
		EXPORT_SYMBOL_GPL(ata_sff_tf_load);

		/**
		* ata_sff_tf_read - input device's ATA taskfile shadow registers
		@@ -633,6 +654,7 @@ void ata_sff_tf_read(struct ata_port ap, struct ata_taskfile tf)
		WARN_ON(1);
		}
		}
		EXPORT_SYMBOL_GPL(ata_sff_tf_read);

		/**
		* ata_sff_exec_command - issue ATA command to host controller
		@@ -652,6 +674,7 @@ void ata_sff_exec_command(struct ata_port ap, const struct ata_taskfile tf)
		iowrite8(tf->command, ap->ioaddr.command_addr);
		ata_sff_pause(ap);
		}
		EXPORT_SYMBOL_GPL(ata_sff_exec_command);

		/**
		* ata_tf_to_host - issue ATA taskfile to host controller
		@@ -717,6 +740,53 @@ unsigned int ata_sff_data_xfer(struct ata_device dev, unsigned char buf,

		return words << 1;
		}
		EXPORT_SYMBOL_GPL(ata_sff_data_xfer);

		/**
		* ata_sff_data_xfer32 - Transfer data by PIO
		* @dev: device to target
		* @buf: data buffer
		* @buflen: buffer length
		* @rw: read/write
		*
		* Transfer data from/to the device data register by PIO using 32bit
		* I/O operations.
		*
		* LOCKING:
		* Inherited from caller.
		*
		* RETURNS:
		* Bytes consumed.
		*/

		unsigned int ata_sff_data_xfer32(struct ata_device dev, unsigned char buf,
		unsigned int buflen, int rw)
		{
		struct ata_port *ap = dev->link->ap;
		void __iomem *data_addr = ap->ioaddr.data_addr;
		unsigned int words = buflen >> 2;
		int slop = buflen & 3;

		/* Transfer multiple of 4 bytes */
		if (rw == READ)
		ioread32_rep(data_addr, buf, words);
		else
		iowrite32_rep(data_addr, buf, words);

		if (unlikely(slop)) {
		__le32 pad;
		if (rw == READ) {
		pad = cpu_to_le32(ioread32(ap->ioaddr.data_addr));
		memcpy(buf + buflen - slop, &pad, slop);
		} else {
		memcpy(&pad, buf + buflen - slop, slop);
		iowrite32(le32_to_cpu(pad), ap->ioaddr.data_addr);
		}
		words++;
		}
		return words << 2;
		}
		EXPORT_SYMBOL_GPL(ata_sff_data_xfer32);

		/**
		* ata_sff_data_xfer_noirq - Transfer data by PIO
		@@ -746,6 +816,7 @@ unsigned int ata_sff_data_xfer_noirq(struct ata_device dev, unsigned char buf,

		return consumed;
		}
		EXPORT_SYMBOL_GPL(ata_sff_data_xfer_noirq);

		/**
		* ata_pio_sector - Transfer a sector of data.
		@@ -922,13 +993,15 @@ next_sg:
		buf = kmap_atomic(page, KM_IRQ0);

		/* do the actual data transfer */
		consumed = ap->ops->sff_data_xfer(dev, buf + offset, count, rw);
		consumed = ap->ops->sff_data_xfer(dev, buf + offset,
		count, rw);

		kunmap_atomic(buf, KM_IRQ0);
		local_irq_restore(flags);
		} else {
		buf = page_address(page);
		consumed = ap->ops->sff_data_xfer(dev, buf + offset, count, rw);
		consumed = ap->ops->sff_data_xfer(dev, buf + offset,
		count, rw);
		}

		bytes -= min(bytes, consumed);
		@@ -1013,7 +1086,8 @@ static void atapi_pio_bytes(struct ata_queued_cmd *qc)
		* RETURNS:
		* 1 if ok in workqueue, 0 otherwise.
		*/
		static inline int ata_hsm_ok_in_wq(struct ata_port ap, struct ata_queued_cmd qc)
		static inline int ata_hsm_ok_in_wq(struct ata_port *ap,
		struct ata_queued_cmd *qc)
		{
		if (qc->tf.flags & ATA_TFLAG_POLLING)
		return 1;
		@@ -1338,6 +1412,7 @@ fsm_start:

		return poll_next;
		}
		EXPORT_SYMBOL_GPL(ata_sff_hsm_move);

		void ata_pio_task(struct work_struct *work)
		{
		@@ -1507,6 +1582,7 @@ unsigned int ata_sff_qc_issue(struct ata_queued_cmd *qc)

		return 0;
		}
		EXPORT_SYMBOL_GPL(ata_sff_qc_issue);

		/**
		* ata_sff_qc_fill_rtf - fill result TF using ->sff_tf_read
		@@ -1526,6 +1602,7 @@ bool ata_sff_qc_fill_rtf(struct ata_queued_cmd *qc)
		qc->ap->ops->sff_tf_read(qc->ap, &qc->result_tf);
		return true;
		}
		EXPORT_SYMBOL_GPL(ata_sff_qc_fill_rtf);

		/**
		* ata_sff_host_intr - Handle host interrupt for given (port, task)
		@@ -1623,6 +1700,7 @@ idle_irq:
		#endif
		return 0; /* irq not handled */
		}
		EXPORT_SYMBOL_GPL(ata_sff_host_intr);

		/**
		* ata_sff_interrupt - Default ATA host interrupt handler
		@@ -1667,6 +1745,7 @@ irqreturn_t ata_sff_interrupt(int irq, void *dev_instance)

		return IRQ_RETVAL(handled);
		}
		EXPORT_SYMBOL_GPL(ata_sff_interrupt);

		/**
		* ata_sff_freeze - Freeze SFF controller port
		@@ -1695,6 +1774,7 @@ void ata_sff_freeze(struct ata_port *ap)

		ap->ops->sff_irq_clear(ap);
		}
		EXPORT_SYMBOL_GPL(ata_sff_freeze);

		/**
		* ata_sff_thaw - Thaw SFF controller port
		@@ -1712,6 +1792,7 @@ void ata_sff_thaw(struct ata_port *ap)
		ap->ops->sff_irq_clear(ap);
		ap->ops->sff_irq_on(ap);
		}
		EXPORT_SYMBOL_GPL(ata_sff_thaw);

		/**
		* ata_sff_prereset - prepare SFF link for reset
		@@ -1753,6 +1834,7 @@ int ata_sff_prereset(struct ata_link *link, unsigned long deadline)

		return 0;
		}
		EXPORT_SYMBOL_GPL(ata_sff_prereset);

		/**
		* ata_devchk - PATA device presence detection
		@@ -1865,6 +1947,7 @@ unsigned int ata_sff_dev_classify(struct ata_device *dev, int present,

		return class;
		}
		EXPORT_SYMBOL_GPL(ata_sff_dev_classify);

		/**
		* ata_sff_wait_after_reset - wait for devices to become ready after reset
		@@ -1941,6 +2024,7 @@ int ata_sff_wait_after_reset(struct ata_link *link, unsigned int devmask,

		return ret;
		}
		EXPORT_SYMBOL_GPL(ata_sff_wait_after_reset);

		static int ata_bus_softreset(struct ata_port *ap, unsigned int devmask,
		unsigned long deadline)
		@@ -2013,6 +2097,7 @@ int ata_sff_softreset(struct ata_link link, unsigned int classes,
		DPRINTK("EXIT, classes[0]=%u [1]=%u\n", classes[0], classes[1]);
		return 0;
		}
		EXPORT_SYMBOL_GPL(ata_sff_softreset);

		/**
		* sata_sff_hardreset - reset host port via SATA phy reset
		@@ -2045,6 +2130,7 @@ int sata_sff_hardreset(struct ata_link link, unsigned int class,
		DPRINTK("EXIT, class=%u\n", *class);
		return rc;
		}
		EXPORT_SYMBOL_GPL(sata_sff_hardreset);

		/**
		* ata_sff_postreset - SFF postreset callback
		@@ -2080,6 +2166,7 @@ void ata_sff_postreset(struct ata_link link, unsigned int classes)
		if (ap->ioaddr.ctl_addr)
		iowrite8(ap->ctl, ap->ioaddr.ctl_addr);
		}
		EXPORT_SYMBOL_GPL(ata_sff_postreset);

		/**
		* ata_sff_error_handler - Stock error handler for BMDMA controller
		@@ -2152,6 +2239,7 @@ void ata_sff_error_handler(struct ata_port *ap)
		ata_do_eh(ap, ap->ops->prereset, softreset, hardreset,
		ap->ops->postreset);
		}
		EXPORT_SYMBOL_GPL(ata_sff_error_handler);

		/**
		* ata_sff_post_internal_cmd - Stock post_internal_cmd for SFF controller
		@@ -2174,6 +2262,7 @@ void ata_sff_post_internal_cmd(struct ata_queued_cmd *qc)

		spin_unlock_irqrestore(ap->lock, flags);
		}
		EXPORT_SYMBOL_GPL(ata_sff_post_internal_cmd);

		/**
		* ata_sff_port_start - Set port up for dma.
		@@ -2194,6 +2283,7 @@ int ata_sff_port_start(struct ata_port *ap)
		return ata_port_start(ap);
		return 0;
		}
		EXPORT_SYMBOL_GPL(ata_sff_port_start);

		/**
		* ata_sff_std_ports - initialize ioaddr with standard port offsets.
		@@ -2219,6 +2309,7 @@ void ata_sff_std_ports(struct ata_ioports *ioaddr)
		ioaddr->status_addr = ioaddr->cmd_addr + ATA_REG_STATUS;
		ioaddr->command_addr = ioaddr->cmd_addr + ATA_REG_CMD;
		}
		EXPORT_SYMBOL_GPL(ata_sff_std_ports);

		unsigned long ata_bmdma_mode_filter(struct ata_device *adev,
		unsigned long xfer_mask)
		@@ -2230,6 +2321,7 @@ unsigned long ata_bmdma_mode_filter(struct ata_device *adev,
		xfer_mask &= ~(ATA_MASK_MWDMA \| ATA_MASK_UDMA);
		return xfer_mask;
		}
		EXPORT_SYMBOL_GPL(ata_bmdma_mode_filter);

		/**
		* ata_bmdma_setup - Set up PCI IDE BMDMA transaction
		@@ -2258,6 +2350,7 @@ void ata_bmdma_setup(struct ata_queued_cmd *qc)
		/* issue r/w command */
		ap->ops->sff_exec_command(ap, &qc->tf);
		}
		EXPORT_SYMBOL_GPL(ata_bmdma_setup);

		/**
		* ata_bmdma_start - Start a PCI IDE BMDMA transaction
		@@ -2290,6 +2383,7 @@ void ata_bmdma_start(struct ata_queued_cmd *qc)
		* unneccessarily delayed for MMIO
		*/
		}
		EXPORT_SYMBOL_GPL(ata_bmdma_start);

		/**
		* ata_bmdma_stop - Stop PCI IDE BMDMA transfer
		@@ -2314,6 +2408,7 @@ void ata_bmdma_stop(struct ata_queued_cmd *qc)
		/* one-PIO-cycle guaranteed wait, per spec, for HDMA1:0 transition */
		ata_sff_dma_pause(ap);
		}
		EXPORT_SYMBOL_GPL(ata_bmdma_stop);

		/**
		* ata_bmdma_status - Read PCI IDE BMDMA status
		@@ -2330,6 +2425,7 @@ u8 ata_bmdma_status(struct ata_port *ap)
		{
		return ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
		}
		EXPORT_SYMBOL_GPL(ata_bmdma_status);

		/**
		* ata_bus_reset - reset host port and associated ATA channel
		@@ -2422,6 +2518,7 @@ err_out:

		DPRINTK("EXIT\n");
		}
		EXPORT_SYMBOL_GPL(ata_bus_reset);

		#ifdef CONFIG_PCI

		@@ -2449,6 +2546,7 @@ int ata_pci_bmdma_clear_simplex(struct pci_dev *pdev)
		return -EOPNOTSUPP;
		return 0;
		}
		EXPORT_SYMBOL_GPL(ata_pci_bmdma_clear_simplex);

		/**
		* ata_pci_bmdma_init - acquire PCI BMDMA resources and init ATA host
		@@ -2506,6 +2604,7 @@ int ata_pci_bmdma_init(struct ata_host *host)

		return 0;
		}
		EXPORT_SYMBOL_GPL(ata_pci_bmdma_init);

		static int ata_resources_present(struct pci_dev *pdev, int port)
		{
		@@ -2598,6 +2697,7 @@ int ata_pci_sff_init_host(struct ata_host *host)

		return 0;
		}
		EXPORT_SYMBOL_GPL(ata_pci_sff_init_host);

		/**
		* ata_pci_sff_prepare_host - helper to prepare native PCI ATA host
		@@ -2656,6 +2756,7 @@ int ata_pci_sff_prepare_host(struct pci_dev *pdev,
		devres_release_group(&pdev->dev, NULL);
		return rc;
		}
		EXPORT_SYMBOL_GPL(ata_pci_sff_prepare_host);

		/**
		* ata_pci_sff_activate_host - start SFF host, request IRQ and register it
		@@ -2749,6 +2850,7 @@ int ata_pci_sff_activate_host(struct ata_host *host,

		return rc;
		}
		EXPORT_SYMBOL_GPL(ata_pci_sff_activate_host);

		/**
		* ata_pci_sff_init_one - Initialize/register PCI IDE host controller
		@@ -2823,54 +2925,7 @@ int ata_pci_sff_init_one(struct pci_dev *pdev,

		return rc;
		}
		EXPORT_SYMBOL_GPL(ata_pci_sff_init_one);

		#endif /* CONFIG_PCI */

		EXPORT_SYMBOL_GPL(ata_sff_port_ops);
		EXPORT_SYMBOL_GPL(ata_bmdma_port_ops);
		EXPORT_SYMBOL_GPL(ata_sff_qc_prep);
		EXPORT_SYMBOL_GPL(ata_sff_dumb_qc_prep);
		EXPORT_SYMBOL_GPL(ata_sff_dev_select);
		EXPORT_SYMBOL_GPL(ata_sff_check_status);
		EXPORT_SYMBOL_GPL(ata_sff_dma_pause);
		EXPORT_SYMBOL_GPL(ata_sff_pause);
		EXPORT_SYMBOL_GPL(ata_sff_busy_sleep);
		EXPORT_SYMBOL_GPL(ata_sff_wait_ready);
		EXPORT_SYMBOL_GPL(ata_sff_tf_load);
		EXPORT_SYMBOL_GPL(ata_sff_tf_read);
		EXPORT_SYMBOL_GPL(ata_sff_exec_command);
		EXPORT_SYMBOL_GPL(ata_sff_data_xfer);
		EXPORT_SYMBOL_GPL(ata_sff_data_xfer_noirq);
		EXPORT_SYMBOL_GPL(ata_sff_irq_on);
		EXPORT_SYMBOL_GPL(ata_sff_irq_clear);
		EXPORT_SYMBOL_GPL(ata_sff_hsm_move);
		EXPORT_SYMBOL_GPL(ata_sff_qc_issue);
		EXPORT_SYMBOL_GPL(ata_sff_qc_fill_rtf);
		EXPORT_SYMBOL_GPL(ata_sff_host_intr);
		EXPORT_SYMBOL_GPL(ata_sff_interrupt);
		EXPORT_SYMBOL_GPL(ata_sff_freeze);
		EXPORT_SYMBOL_GPL(ata_sff_thaw);
		EXPORT_SYMBOL_GPL(ata_sff_prereset);
		EXPORT_SYMBOL_GPL(ata_sff_dev_classify);
		EXPORT_SYMBOL_GPL(ata_sff_wait_after_reset);
		EXPORT_SYMBOL_GPL(ata_sff_softreset);
		EXPORT_SYMBOL_GPL(sata_sff_hardreset);
		EXPORT_SYMBOL_GPL(ata_sff_postreset);
		EXPORT_SYMBOL_GPL(ata_sff_error_handler);
		EXPORT_SYMBOL_GPL(ata_sff_post_internal_cmd);
		EXPORT_SYMBOL_GPL(ata_sff_port_start);
		EXPORT_SYMBOL_GPL(ata_sff_std_ports);
		EXPORT_SYMBOL_GPL(ata_bmdma_mode_filter);
		EXPORT_SYMBOL_GPL(ata_bmdma_setup);
		EXPORT_SYMBOL_GPL(ata_bmdma_start);
		EXPORT_SYMBOL_GPL(ata_bmdma_stop);
		EXPORT_SYMBOL_GPL(ata_bmdma_status);
		EXPORT_SYMBOL_GPL(ata_bus_reset);
		#ifdef CONFIG_PCI
		EXPORT_SYMBOL_GPL(ata_pci_bmdma_clear_simplex);
		EXPORT_SYMBOL_GPL(ata_pci_bmdma_init);
		EXPORT_SYMBOL_GPL(ata_pci_sff_init_host);
		EXPORT_SYMBOL_GPL(ata_pci_sff_prepare_host);
		EXPORT_SYMBOL_GPL(ata_pci_sff_activate_host);
		EXPORT_SYMBOL_GPL(ata_pci_sff_init_one);
		#endif /* CONFIG_PCI */

drivers/ata/pata_ali.c

+70 −37

Original line number	Diff line number	Diff line
		@@ -19,7 +19,9 @@
		*
		* TODO/CHECK
		* Cannot have ATAPI on both master & slave for rev < c2 (???) but
		* otherwise should do atapi DMA.
		* otherwise should do atapi DMA (For now for old we do PIO only for
		* ATAPI)
		* Review Sunblade workaround.
		*/

		#include <linux/kernel.h>
		@@ -33,12 +35,14 @@
		#include <linux/dmi.h>

		#define DRV_NAME "pata_ali"
		#define DRV_VERSION "0.7.5"
		#define DRV_VERSION "0.7.8"

		static int ali_atapi_dma = 0;
		module_param_named(atapi_dma, ali_atapi_dma, int, 0644);
		MODULE_PARM_DESC(atapi_dma, "Enable ATAPI DMA (0=disable, 1=enable)");

		static struct pci_dev *isa_bridge;

		/*
		* Cable special cases
		*/
		@@ -147,7 +151,6 @@ static void ali_fifo_control(struct ata_port ap, struct ata_device adev, int o

		pci_read_config_byte(pdev, pio_fifo, &fifo);
		fifo &= ~(0x0F << shift);
		if (on)
		fifo \|= (on << shift);
		pci_write_config_byte(pdev, pio_fifo, fifo);
		}
		@@ -337,6 +340,23 @@ static int ali_check_atapi_dma(struct ata_queued_cmd *qc)
		return 0;
		}

		static void ali_c2_c3_postreset(struct ata_link link, unsigned int classes)
		{
		u8 r;
		int port_bit = 4 << link->ap->port_no;

		/* If our bridge is an ALI 1533 then do the extra work */
		if (isa_bridge) {
		/* Tristate and re-enable the bus signals */
		pci_read_config_byte(isa_bridge, 0x58, &r);
		r &= ~port_bit;
		pci_write_config_byte(isa_bridge, 0x58, r);
		r \|= port_bit;
		pci_write_config_byte(isa_bridge, 0x58, r);
		}
		ata_sff_postreset(link, classes);
		}

		static struct scsi_host_template ali_sht = {
		ATA_BMDMA_SHT(DRV_NAME),
		};
		@@ -349,10 +369,11 @@ static struct ata_port_operations ali_early_port_ops = {
		.inherits = &ata_sff_port_ops,
		.cable_detect = ata_cable_40wire,
		.set_piomode = ali_set_piomode,
		.sff_data_xfer = ata_sff_data_xfer32,
		};

		static const struct ata_port_operations ali_dma_base_ops = {
		.inherits = &ata_bmdma_port_ops,
		.inherits = &ata_bmdma32_port_ops,
		.set_piomode = ali_set_piomode,
		.set_dmamode = ali_set_dmamode,
		};
		@@ -377,6 +398,17 @@ static struct ata_port_operations ali_c2_port_ops = {
		.check_atapi_dma = ali_check_atapi_dma,
		.cable_detect = ali_c2_cable_detect,
		.dev_config = ali_lock_sectors,
		.postreset = ali_c2_c3_postreset,
		};

		/*
		* Port operations for DMA capable ALi with cable detect
		*/
		static struct ata_port_operations ali_c4_port_ops = {
		.inherits = &ali_dma_base_ops,
		.check_atapi_dma = ali_check_atapi_dma,
		.cable_detect = ali_c2_cable_detect,
		.dev_config = ali_lock_sectors,
		};

		/*
		@@ -401,52 +433,49 @@ static struct ata_port_operations ali_c5_port_ops = {
		static void ali_init_chipset(struct pci_dev *pdev)
		{
		u8 tmp;
		struct pci_dev north, isa_bridge;
		struct pci_dev *north;

		/*
		* The chipset revision selects the driver operations and
		* mode data.
		*/

		if (pdev->revision >= 0x20 && pdev->revision < 0xC2) {
		/* 1543-E/F, 1543C-C, 1543C-D, 1543C-E */
		if (pdev->revision <= 0x20) {
		pci_read_config_byte(pdev, 0x53, &tmp);
		tmp \|= 0x03;
		pci_write_config_byte(pdev, 0x53, tmp);
		} else {
		pci_read_config_byte(pdev, 0x4a, &tmp);
		pci_write_config_byte(pdev, 0x4a, tmp \| 0x20);
		pci_read_config_byte(pdev, 0x4B, &tmp);
		if (pdev->revision < 0xC2)
		/* 1543-E/F, 1543C-C, 1543C-D, 1543C-E */
		/* Clear CD-ROM DMA write bit */
		tmp &= 0x7F;
		pci_write_config_byte(pdev, 0x4B, tmp);
		} else if (pdev->revision >= 0xC2) {
		/* Enable cable detection logic */
		pci_read_config_byte(pdev, 0x4B, &tmp);
		pci_write_config_byte(pdev, 0x4B, tmp \| 0x08);
		}
		north = pci_get_bus_and_slot(0, PCI_DEVFN(0,0));
		isa_bridge = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533, NULL);

		if (north && north->vendor == PCI_VENDOR_ID_AL && isa_bridge) {
		/* Configure the ALi bridge logic. For non ALi rely on BIOS.
		Set the south bridge enable bit */
		pci_read_config_byte(isa_bridge, 0x79, &tmp);
		if (pdev->revision == 0xC2)
		pci_write_config_byte(isa_bridge, 0x79, tmp \| 0x04);
		else if (pdev->revision > 0xC2 && pdev->revision < 0xC5)
		pci_write_config_byte(isa_bridge, 0x79, tmp \| 0x02);
		}
		if (pdev->revision >= 0x20) {
		/* Cable and UDMA */
		pci_write_config_byte(pdev, 0x4B, tmp \| 0x09);
		/*
		* CD_ROM DMA on (0x53 bit 0). Enable this even if we want
		* to use PIO. 0x53 bit 1 (rev 20 only) - enable FIFO control
		* via 0x54/55.
		*/
		pci_read_config_byte(pdev, 0x53, &tmp);
		if (pdev->revision <= 0x20)
		tmp &= ~0x02;
		if (pdev->revision >= 0xc7)
		tmp \|= 0x03;
		else
		tmp \|= 0x01; /* CD_ROM enable for DMA */
		pci_write_config_byte(pdev, 0x53, tmp);
		}
		pci_dev_put(isa_bridge);
		north = pci_get_bus_and_slot(0, PCI_DEVFN(0,0));
		if (north && north->vendor == PCI_VENDOR_ID_AL && isa_bridge) {
		/* Configure the ALi bridge logic. For non ALi rely on BIOS.
		Set the south bridge enable bit */
		pci_read_config_byte(isa_bridge, 0x79, &tmp);
		if (pdev->revision == 0xC2)
		pci_write_config_byte(isa_bridge, 0x79, tmp \| 0x04);
		else if (pdev->revision > 0xC2 && pdev->revision < 0xC5)
		pci_write_config_byte(isa_bridge, 0x79, tmp \| 0x02);
		}
		pci_dev_put(north);
		ata_pci_bmdma_clear_simplex(pdev);
		}
		@@ -503,7 +532,7 @@ static int ali_init_one(struct pci_dev pdev, const struct pci_device_id id)
		.pio_mask = 0x1f,
		.mwdma_mask = 0x07,
		.udma_mask = ATA_UDMA5,
		.port_ops = &ali_c2_port_ops
		.port_ops = &ali_c4_port_ops
		};
		/* Revision 0xC5 is UDMA133 with LBA48 DMA */
		static const struct ata_port_info info_c5 = {
		@@ -516,7 +545,6 @@ static int ali_init_one(struct pci_dev pdev, const struct pci_device_id id)

		const struct ata_port_info *ppi[] = { NULL, NULL };
		u8 tmp;
		struct pci_dev *isa_bridge;
		int rc;

		rc = pcim_enable_device(pdev);
		@@ -543,14 +571,12 @@ static int ali_init_one(struct pci_dev pdev, const struct pci_device_id id)

		ali_init_chipset(pdev);

		isa_bridge = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533, NULL);
		if (isa_bridge && pdev->revision >= 0x20 && pdev->revision < 0xC2) {
		/* Are we paired with a UDMA capable chip */
		pci_read_config_byte(isa_bridge, 0x5E, &tmp);
		if ((tmp & 0x1E) == 0x12)
		ppi[0] = &info_20_udma;
		}
		pci_dev_put(isa_bridge);

		return ata_pci_sff_init_one(pdev, ppi, &ali_sht, NULL);
		}
		@@ -590,13 +616,20 @@ static struct pci_driver ali_pci_driver = {

		static int __init ali_init(void)
		{
		return pci_register_driver(&ali_pci_driver);
		int ret;
		isa_bridge = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533, NULL);

		ret = pci_register_driver(&ali_pci_driver);
		if (ret < 0)
		pci_dev_put(isa_bridge);
		return ret;
		}


		static void __exit ali_exit(void)
		{
		pci_unregister_driver(&ali_pci_driver);
		pci_dev_put(isa_bridge);
		}

Admin message