Commit a1efdaba authored by Tejun Heo's avatar Tejun Heo Committed by Jeff Garzik
Browse files

libata: make reset related methods proper port operations 



Currently reset methods are not specified directly in the
ata_port_operations table.  If a LLD wants to use custom reset
methods, it should construct and use a error_handler which uses those
reset methods.  It's done this way for two reasons.

First, the ops table already contained too many methods and adding
four more of them would noticeably increase the amount of necessary
boilerplate code all over low level drivers.

Second, as ->error_handler uses those reset methods, it can get
confusing.  ie. By overriding ->error_handler, those reset ops can be
made useless making layering a bit hazy.

Now that ops table uses inheritance, the first problem doesn't exist
anymore.  The second isn't completely solved but is relieved by
providing default values - most drivers can just override what it has
implemented and don't have to concern itself about higher level
callbacks.  In fact, there currently is no driver which actually
modifies error handling behavior.  Drivers which override
->error_handler just wraps the standard error handler only to prepare
the controller for EH.  I don't think making ops layering strict has
any noticeable benefit.

This patch makes ->prereset, ->softreset, ->hardreset, ->postreset and
their PMP counterparts propoer ops.  Default ops are provided in the
base ops tables and drivers are converted to override individual reset
methods instead of creating custom error_handler.

* ata_std_error_handler() doesn't use sata_std_hardreset() if SCRs
  aren't accessible.  sata_promise doesn't need to use separate
  error_handlers for PATA and SATA anymore.

* softreset is broken for sata_inic162x and sata_sx4.  As libata now
  always prefers hardreset, this doesn't really matter but the ops are
  forced to NULL using ATA_OP_NULL for documentation purpose.

* pata_hpt374 needs to use different prereset for the first and second
  PCI functions.  This used to be done by branching from
  hpt374_error_handler().  The proper way to do this is to use
  separate ops and port_info tables for each function.  Converted.

Signed-off-by: default avatarTejun Heo <htejun@gmail.com>
parent 95947193

drivers/ata/ahci.c

+18 −35
Original line number Diff line number Diff line
@@ -252,9 +252,18 @@ static void ahci_freeze(struct ata_port *ap); 
static void ahci_thaw(struct ata_port *ap);

static void ahci_pmp_attach(struct ata_port *ap);

static void ahci_pmp_detach(struct ata_port *ap);

static int ahci_softreset(struct ata_link *link, unsigned int *class,

			  unsigned long deadline);

static int ahci_hardreset(struct ata_link *link, unsigned int *class,

			  unsigned long deadline);

static int ahci_vt8251_hardreset(struct ata_link *link, unsigned int *class,

				 unsigned long deadline);

static int ahci_p5wdh_hardreset(struct ata_link *link, unsigned int *class,

				unsigned long deadline);

static void ahci_postreset(struct ata_link *link, unsigned int *class);

static int ahci_pmp_softreset(struct ata_link *link, unsigned int *class,

			      unsigned long deadline);

static void ahci_error_handler(struct ata_port *ap);

static void ahci_vt8251_error_handler(struct ata_port *ap);

static void ahci_p5wdh_error_handler(struct ata_port *ap);

static void ahci_post_internal_cmd(struct ata_queued_cmd *qc);

static int ahci_port_resume(struct ata_port *ap);

static void ahci_dev_config(struct ata_device *dev);
@@ -293,6 +302,10 @@ static struct ata_port_operations ahci_ops = { 


	.freeze			= ahci_freeze,

	.thaw			= ahci_thaw,

	.softreset		= ahci_softreset,

	.hardreset		= ahci_hardreset,

	.postreset		= ahci_postreset,

	.pmp_softreset		= ahci_pmp_softreset,

	.error_handler		= ahci_error_handler,

	.post_internal_cmd	= ahci_post_internal_cmd,

	.dev_config		= ahci_dev_config,
@@ -314,12 +327,12 @@ static struct ata_port_operations ahci_ops = { 


static struct ata_port_operations ahci_vt8251_ops = {

	.inherits		= &ahci_ops,

	.error_handler		= ahci_vt8251_error_handler,

	.hardreset		= ahci_vt8251_hardreset,

};



static struct ata_port_operations ahci_p5wdh_ops = {

	.inherits		= &ahci_ops,

	.error_handler		= ahci_p5wdh_error_handler,

	.hardreset		= ahci_p5wdh_hardreset,

};



#define AHCI_HFLAGS(flags)	.private_data	= (void *)(flags)
@@ -1796,37 +1809,7 @@ static void ahci_error_handler(struct ata_port *ap) 
		ahci_start_engine(ap);

	}



	/* perform recovery */

	sata_pmp_do_eh(ap, ata_std_prereset, ahci_softreset,

		       ahci_hardreset, ahci_postreset,

		       sata_pmp_std_prereset, ahci_pmp_softreset,

		       sata_pmp_std_hardreset, sata_pmp_std_postreset);

}



static void ahci_vt8251_error_handler(struct ata_port *ap)

{

	if (!(ap->pflags & ATA_PFLAG_FROZEN)) {

		/* restart engine */

		ahci_stop_engine(ap);

		ahci_start_engine(ap);

	}



	/* perform recovery */

	ata_do_eh(ap, ata_std_prereset, ahci_softreset, ahci_vt8251_hardreset,

		  ahci_postreset);

}



static void ahci_p5wdh_error_handler(struct ata_port *ap)

{

	if (!(ap->pflags & ATA_PFLAG_FROZEN)) {

		/* restart engine */

		ahci_stop_engine(ap);

		ahci_start_engine(ap);

	}



	/* perform recovery */

	ata_do_eh(ap, ata_std_prereset, ahci_softreset, ahci_p5wdh_hardreset,

		  ahci_postreset);

	sata_pmp_error_handler(ap);

}



static void ahci_post_internal_cmd(struct ata_queued_cmd *qc)

drivers/ata/ata_piix.c

+5 −16
Original line number Diff line number Diff line
@@ -162,15 +162,16 @@ struct piix_host_priv { 


static int piix_init_one(struct pci_dev *pdev,

			 const struct pci_device_id *ent);

static void piix_pata_error_handler(struct ata_port *ap);

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_hardreset(struct ata_link *link, unsigned int *class,

				unsigned long deadline);

static int piix_sidpr_scr_read(struct ata_port *ap, unsigned int reg, u32 *val);

static int piix_sidpr_scr_write(struct ata_port *ap, unsigned int reg, u32 val);

static void piix_sidpr_error_handler(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);
@@ -299,7 +300,7 @@ static struct ata_port_operations piix_pata_ops = { 
	.cable_detect		= ata_cable_40wire,

	.set_piomode		= piix_set_piomode,

	.set_dmamode		= piix_set_dmamode,

	.error_handler		= piix_pata_error_handler,

	.prereset		= piix_pata_prereset,

};



static struct ata_port_operations piix_vmw_ops = {
@@ -319,9 +320,9 @@ static struct ata_port_operations piix_sata_ops = { 


static struct ata_port_operations piix_sidpr_sata_ops = {

	.inherits		= &piix_sata_ops,

	.hardreset		= piix_sidpr_hardreset,

	.scr_read		= piix_sidpr_scr_read,

	.scr_write		= piix_sidpr_scr_write,

	.error_handler		= piix_sidpr_error_handler,

};



static const struct piix_map_db ich5_map_db = {
@@ -645,12 +646,6 @@ static int piix_pata_prereset(struct ata_link *link, unsigned long deadline) 
	return ata_std_prereset(link, deadline);

}



static void piix_pata_error_handler(struct ata_port *ap)

{

	ata_bmdma_drive_eh(ap, piix_pata_prereset, ata_std_softreset, NULL,

			   ata_std_postreset);

}



/**

 *	piix_set_piomode - Initialize host controller PATA PIO timings

 *	@ap: Port whose timings we are configuring
@@ -1057,12 +1052,6 @@ static int piix_sidpr_hardreset(struct ata_link *link, unsigned int *class, 
	return -EAGAIN;

}



static void piix_sidpr_error_handler(struct ata_port *ap)

{

	ata_bmdma_drive_eh(ap, ata_std_prereset, ata_std_softreset,

			   piix_sidpr_hardreset, ata_std_postreset);

}



#ifdef CONFIG_PM

static int piix_broken_suspend(void)

{

drivers/ata/libata-core.c

+12 −2
Original line number Diff line number Diff line
@@ -76,6 +76,10 @@ const unsigned long sata_deb_timing_long[] = { 100, 2000, 5000 }; 


const struct ata_port_operations ata_base_port_ops = {

	.irq_clear		= ata_noop_irq_clear,

	.prereset		= ata_std_prereset,

	.hardreset		= sata_std_hardreset,

	.postreset		= ata_std_postreset,

	.error_handler		= ata_std_error_handler,

};



const struct ata_port_operations sata_port_ops = {
@@ -87,6 +91,11 @@ const struct ata_port_operations sata_port_ops = { 


const struct ata_port_operations sata_pmp_port_ops = {

	.inherits		= &sata_port_ops,



	.pmp_prereset		= sata_pmp_std_prereset,

	.pmp_hardreset		= sata_pmp_std_hardreset,

	.pmp_postreset		= sata_pmp_std_postreset,

	.error_handler		= sata_pmp_error_handler,

};



const struct ata_port_operations ata_sff_port_ops = {
@@ -97,6 +106,7 @@ const struct ata_port_operations ata_sff_port_ops = { 


	.freeze			= ata_bmdma_freeze,

	.thaw			= ata_bmdma_thaw,

	.softreset		= ata_std_softreset,

	.error_handler		= ata_bmdma_error_handler,

	.post_internal_cmd	= ata_bmdma_post_internal_cmd,
@@ -7935,7 +7945,6 @@ EXPORT_SYMBOL_GPL(ata_bmdma_status); 
EXPORT_SYMBOL_GPL(ata_bmdma_stop);

EXPORT_SYMBOL_GPL(ata_bmdma_freeze);

EXPORT_SYMBOL_GPL(ata_bmdma_thaw);

EXPORT_SYMBOL_GPL(ata_bmdma_drive_eh);

EXPORT_SYMBOL_GPL(ata_bmdma_error_handler);

EXPORT_SYMBOL_GPL(ata_bmdma_post_internal_cmd);

EXPORT_SYMBOL_GPL(ata_port_probe);
@@ -8005,7 +8014,7 @@ EXPORT_SYMBOL_GPL(sata_pmp_qc_defer_cmd_switch); 
EXPORT_SYMBOL_GPL(sata_pmp_std_prereset);

EXPORT_SYMBOL_GPL(sata_pmp_std_hardreset);

EXPORT_SYMBOL_GPL(sata_pmp_std_postreset);

EXPORT_SYMBOL_GPL(sata_pmp_do_eh);

EXPORT_SYMBOL_GPL(sata_pmp_error_handler);



EXPORT_SYMBOL_GPL(__ata_ehi_push_desc);

EXPORT_SYMBOL_GPL(ata_ehi_push_desc);
@@ -8024,6 +8033,7 @@ EXPORT_SYMBOL_GPL(ata_eh_thaw_port); 
EXPORT_SYMBOL_GPL(ata_eh_qc_complete);

EXPORT_SYMBOL_GPL(ata_eh_qc_retry);

EXPORT_SYMBOL_GPL(ata_do_eh);

EXPORT_SYMBOL_GPL(ata_std_error_handler);

EXPORT_SYMBOL_GPL(ata_irq_on);

EXPORT_SYMBOL_GPL(ata_dev_try_classify);

drivers/ata/libata-eh.c

+25 −0
Original line number Diff line number Diff line
@@ -2814,6 +2814,7 @@ void ata_eh_finish(struct ata_port *ap) 
/**

 *	ata_do_eh - do standard error handling

 *	@ap: host port to handle error for

 *

 *	@prereset: prereset method (can be NULL)

 *	@softreset: softreset method (can be NULL)

 *	@hardreset: hardreset method (can be NULL)
@@ -2844,6 +2845,30 @@ void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset, 
	ata_eh_finish(ap);

}



/**

 *	ata_std_error_handler - standard error handler

 *	@ap: host port to handle error for

 *

 *	Standard error handler

 *

 *	LOCKING:

 *	Kernel thread context (may sleep).

 */

void ata_std_error_handler(struct ata_port *ap)

{

	struct ata_port_operations *ops = ap->ops;

	ata_reset_fn_t hardreset = ops->hardreset;



	/* sata_std_hardreset is inherited to all drivers from

	 * ata_base_port_ops.  Ignore it if SCR access is not

	 * available.

	 */

	if (hardreset == sata_std_hardreset && !sata_scr_valid(&ap->link))

		hardreset = NULL;



	ata_do_eh(ap, ops->prereset, ops->softreset, hardreset, ops->postreset);

}



#ifdef CONFIG_PM

/**

 *	ata_eh_handle_port_suspend - perform port suspend operation

drivers/ata/libata-pmp.c

+11 −36
Original line number Diff line number Diff line
@@ -962,14 +962,6 @@ static int sata_pmp_handle_link_fail(struct ata_link *link, int *link_tries) 
/**

 *	sata_pmp_eh_recover - recover PMP-enabled port

 *	@ap: ATA port to recover

 *	@prereset: prereset method (can be NULL)

 *	@softreset: softreset method

 *	@hardreset: hardreset method

 *	@postreset: postreset method (can be NULL)

 *	@pmp_prereset: PMP prereset method (can be NULL)

 *	@pmp_softreset: PMP softreset method (can be NULL)

 *	@pmp_hardreset: PMP hardreset method (can be NULL)

 *	@pmp_postreset: PMP postreset method (can be NULL)

 *

 *	Drive EH recovery operation for PMP enabled port @ap.  This

 *	function recovers host and PMP ports with proper retrials and
@@ -982,12 +974,9 @@ static int sata_pmp_handle_link_fail(struct ata_link *link, int *link_tries) 
 *	RETURNS:

 *	0 on success, -errno on failure.

 */

static int sata_pmp_eh_recover(struct ata_port *ap,

		ata_prereset_fn_t prereset, ata_reset_fn_t softreset,

		ata_reset_fn_t hardreset, ata_postreset_fn_t postreset,

		ata_prereset_fn_t pmp_prereset, ata_reset_fn_t pmp_softreset,

		ata_reset_fn_t pmp_hardreset, ata_postreset_fn_t pmp_postreset)

static int sata_pmp_eh_recover(struct ata_port *ap)

{

	struct ata_port_operations *ops = ap->ops;

	int pmp_tries, link_tries[SATA_PMP_MAX_PORTS];

	struct ata_link *pmp_link = &ap->link;

	struct ata_device *pmp_dev = pmp_link->device;
@@ -1005,8 +994,8 @@ static int sata_pmp_eh_recover(struct ata_port *ap, 
 retry:

	/* PMP attached? */

	if (!ap->nr_pmp_links) {

		rc = ata_eh_recover(ap, prereset, softreset, hardreset,

				    postreset, NULL);

		rc = ata_eh_recover(ap, ops->prereset, ops->softreset,

				    ops->hardreset, ops->postreset, NULL);

		if (rc) {

			ata_link_for_each_dev(dev, &ap->link)

				ata_dev_disable(dev);
@@ -1024,8 +1013,8 @@ static int sata_pmp_eh_recover(struct ata_port *ap, 
	}



	/* recover pmp */

	rc = sata_pmp_eh_recover_pmp(ap, prereset, softreset, hardreset,

				     postreset);

	rc = sata_pmp_eh_recover_pmp(ap, ops->prereset, ops->softreset,

				     ops->hardreset, ops->postreset);

	if (rc)

		goto pmp_fail;
@@ -1035,8 +1024,8 @@ static int sata_pmp_eh_recover(struct ata_port *ap, 
		goto pmp_fail;



	/* recover links */

	rc = ata_eh_recover(ap, pmp_prereset, pmp_softreset, pmp_hardreset,

			    pmp_postreset, &link);

	rc = ata_eh_recover(ap, ops->pmp_prereset, ops->pmp_softreset,

			    ops->pmp_hardreset, ops->pmp_postreset, &link);

	if (rc)

		goto link_fail;
@@ -1132,16 +1121,8 @@ static int sata_pmp_eh_recover(struct ata_port *ap, 
}



/**

 *	sata_pmp_do_eh - do standard error handling for PMP-enabled host

 *	sata_pmp_error_handler - do standard error handling for PMP-enabled host

 *	@ap: host port to handle error for

 *	@prereset: prereset method (can be NULL)

 *	@softreset: softreset method

 *	@hardreset: hardreset method

 *	@postreset: postreset method (can be NULL)

 *	@pmp_prereset: PMP prereset method (can be NULL)

 *	@pmp_softreset: PMP softreset method (can be NULL)

 *	@pmp_hardreset: PMP hardreset method (can be NULL)

 *	@pmp_postreset: PMP postreset method (can be NULL)

 *

 *	Perform standard error handling sequence for PMP-enabled host

 *	@ap.
@@ -1149,16 +1130,10 @@ static int sata_pmp_eh_recover(struct ata_port *ap, 
 *	LOCKING:

 *	Kernel thread context (may sleep).

 */

void sata_pmp_do_eh(struct ata_port *ap,

		ata_prereset_fn_t prereset, ata_reset_fn_t softreset,

		ata_reset_fn_t hardreset, ata_postreset_fn_t postreset,

		ata_prereset_fn_t pmp_prereset, ata_reset_fn_t pmp_softreset,

		ata_reset_fn_t pmp_hardreset, ata_postreset_fn_t pmp_postreset)

void sata_pmp_error_handler(struct ata_port *ap)

{

	ata_eh_autopsy(ap);

	ata_eh_report(ap);

	sata_pmp_eh_recover(ap, prereset, softreset, hardreset, postreset,

			    pmp_prereset, pmp_softreset, pmp_hardreset,

			    pmp_postreset);

	sata_pmp_eh_recover(ap);

	ata_eh_finish(ap);

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE