Commit 5387373b authored by Mikael Pettersson's avatar Mikael Pettersson Committed by Jeff Garzik
Browse files

sata_promise: new EH conversion for 20619 chips, take 2 



This patch updates the sata_promise driver to use new-style
libata error handling for 20619 (TX4000) chips. sata_promise
already uses new EH for the other chips it supports, so the
patch is quite simple:

* remove ->phy_reset and ->eng_timeout ops from pdc_pata_ops,
  and instead bind ->freeze, ->thaw, ->error_handler, and
  ->post_internal_cmd to existing new EH functions
* drop ATA_FLAG_SRST from board_20619's flags
* remove now unused pdc_pata_phy_reset() and pdc_eng_timeout()

Tested on a TX4000 with both modern working disks and old/quirky
disks. Also used a CD-RW drive to test reading and writing CDs.

Signed-off-by: default avatarMikael Pettersson <mikpe@it.uu.se>
Signed-off-by: default avatarJeff Garzik <jeff@garzik.org>
parent 2fb8b49f

drivers/ata/sata_promise.c

+4 −51
Original line number Diff line number Diff line
@@ -119,9 +119,7 @@ static u32 pdc_sata_scr_read (struct ata_port *ap, unsigned int sc_reg); 
static void pdc_sata_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);

static int pdc_ata_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);

static irqreturn_t pdc_interrupt (int irq, void *dev_instance);

static void pdc_eng_timeout(struct ata_port *ap);

static int pdc_port_start(struct ata_port *ap);

static void pdc_pata_phy_reset(struct ata_port *ap);

static void pdc_qc_prep(struct ata_queued_cmd *qc);

static void pdc_tf_load_mmio(struct ata_port *ap, const struct ata_taskfile *tf);

static void pdc_exec_command_mmio(struct ata_port *ap, const struct ata_taskfile *tf);
@@ -215,12 +213,12 @@ static const struct ata_port_operations pdc_pata_ops = { 
	.dev_select		= ata_std_dev_select,

	.check_atapi_dma	= pdc_check_atapi_dma,



	.phy_reset		= pdc_pata_phy_reset,



	.qc_prep		= pdc_qc_prep,

	.qc_issue		= pdc_qc_issue_prot,

	.freeze			= pdc_freeze,

	.thaw			= pdc_thaw,

	.error_handler		= pdc_error_handler,

	.data_xfer		= ata_data_xfer,

	.eng_timeout		= pdc_eng_timeout,

	.irq_handler		= pdc_interrupt,

	.irq_clear		= pdc_irq_clear,

	.irq_on			= ata_irq_on,
@@ -253,7 +251,7 @@ static const struct ata_port_info pdc_port_info[] = { 
	/* board_20619 */

	{

		.sht		= &pdc_ata_sht,

		.flags		= PDC_COMMON_FLAGS | ATA_FLAG_SRST | ATA_FLAG_SLAVE_POSS,

		.flags		= PDC_COMMON_FLAGS | ATA_FLAG_SLAVE_POSS,

		.pio_mask	= 0x1f, /* pio0-4 */

		.mwdma_mask	= 0x07, /* mwdma0-2 */

		.udma_mask	= 0x7f, /* udma0-6 ; FIXME */
@@ -389,14 +387,6 @@ static void pdc_pata_cbl_detect(struct ata_port *ap) 
		ap->cbl = ATA_CBL_PATA80;

}



static void pdc_pata_phy_reset(struct ata_port *ap)

{

	pdc_pata_cbl_detect(ap);

	pdc_reset_port(ap);

	ata_port_probe(ap);

	ata_bus_reset(ap);

}



static u32 pdc_sata_scr_read (struct ata_port *ap, unsigned int sc_reg)

{

	if (sc_reg > SCR_CONTROL || ap->cbl != ATA_CBL_SATA)
@@ -599,43 +589,6 @@ static void pdc_post_internal_cmd(struct ata_queued_cmd *qc) 
		pdc_reset_port(ap);

}



static void pdc_eng_timeout(struct ata_port *ap)

{

	struct ata_host *host = ap->host;

	u8 drv_stat;

	struct ata_queued_cmd *qc;

	unsigned long flags;



	DPRINTK("ENTER\n");



	spin_lock_irqsave(&host->lock, flags);



	qc = ata_qc_from_tag(ap, ap->active_tag);



	switch (qc->tf.protocol) {

	case ATA_PROT_DMA:

	case ATA_PROT_NODATA:

		ata_port_printk(ap, KERN_ERR, "command timeout\n");

		drv_stat = ata_wait_idle(ap);

		qc->err_mask |= __ac_err_mask(drv_stat);

		break;



	default:

		drv_stat = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);



		ata_port_printk(ap, KERN_ERR,

				"unknown timeout, cmd 0x%x stat 0x%x\n",

				qc->tf.command, drv_stat);



		qc->err_mask |= ac_err_mask(drv_stat);

		break;

	}



	spin_unlock_irqrestore(&host->lock, flags);

	ata_eh_qc_complete(qc);

	DPRINTK("EXIT\n");

}



static inline unsigned int pdc_host_intr( struct ata_port *ap,

                                          struct ata_queued_cmd *qc)

{

CRA Git | Maintained and supported by SUSTech CRA and CCSE