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

Commit a419df8a 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:
  libata: clean up the SFF code for coding style
  libata: Add 32bit PIO support
  [libata] ahci: Withdraw IGN_SERR_INTERNAL for SB800 SATA
  pata_hpt366: reimplement mode programming
  [libata] pata_hpt3x3: correct _freeze() function declaration
  libata: Add special ata_pio_need_iordy() handling for Compact Flash.
  pata_platform: __pata_platform_remove() shouldn't be in discard section
  sata_sil24: remove unused sil24_port_multiplier
  [libata] ahci: Add SATA GEN3 related messages
  ata_piix: save, use saved and restore IOCFG
  pata_ali: Fix and workaround for FIFO DMA bug
  pata_ali: force initialise a few bits
  pata_hpt3x3: Workarounds for chipset
parents 33b04b93 0fe40ff8

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

}