ata: libata-eh: Remove ata_do_eh()

The only reason for ata_do_eh() to exist is that the two caller sites,
ata_std_error_handler() and ata_sff_error_handler() may pass it a
NULL hardreset operation so that the built-in (generic) hardreset
operation for a driver is ignored if the adapter SCR access is not
available.

However, ata_std_error_handler() and ata_sff_error_handler()
modifications of the hardreset port operation can easily be combined as
they are mutually exclusive. That is, a driver using sata_std_hardreset()
as its hardreset operation cannot use sata_sff_hardreset() and
vice-versa.

With this observation, ata_do_eh() can be removed and its code moved to
ata_std_error_handler(). The condition used to ignore the built-in
hardreset port operation is modified to be the one that was used in
ata_sff_error_handler(). This requires defining a stub for the function
sata_sff_hardreset() to avoid compilation errors when CONFIG_ATA_SFF is
not enabled. Furthermore, instead of modifying the local hardreset
operation definition, set the ATA_LFLAG_NO_HRST link flag to prevent
the use of built-in hardreset methods for ports without a valid scr_read
function. This flag is checked in ata_eh_reset() and if set, the
hardreset method is ignored.

This change simplifies ata_sff_error_handler() as this function now only
needs to call ata_std_error_handler().

No functional changes.

Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
Reviewed-by: Niklas Cassel <cassel@kernel.org>
Reviewed-by: Martin K. Petersen <martin.petersen@oracle.com>
Reviewed-by: Hannes Reinecke <hare@suse.de>
Link: https://lore.kernel.org/r/20250716020315.235457-2-dlemoal@kernel.org
Signed-off-by: Niklas Cassel <cassel@kernel.org>

diff --git a/drivers/ata/libata-eh.c b/drivers/ata/libata-eh.c
index 436536112043ce6adbc697e573118e38db269b97..30c831e56a7fd893f8bdbcf5e4d34c75788e31af 100644 (file)
--- a/drivers/ata/libata-eh.c
+++ b/drivers/ata/libata-eh.c
@@ -4067,59 +4067,39 @@ void ata_eh_finish(struct ata_port *ap)
 }
 
 /**
- *     ata_do_eh - do standard error handling
+ *     ata_std_error_handler - standard error handler
  *     @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)
- *     @postreset: postreset method (can be NULL)
- *
  *     Perform standard error handling sequence.
  *
  *     LOCKING:
  *     Kernel thread context (may sleep).
  */
-void ata_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)
+void ata_std_error_handler(struct ata_port *ap)
 {
-       struct ata_device *dev;
+       struct ata_port_operations *ops = ap->ops;
+       struct ata_link *link = &ap->link;
        int rc;
 
+       /* Ignore built-in hardresets if SCR access is not available */
+       if ((ops->hardreset == sata_std_hardreset ||
+            ops->hardreset == sata_sff_hardreset) && !sata_scr_valid(link))
+               link->flags |= ATA_LFLAG_NO_HRST;
+
        ata_eh_autopsy(ap);
        ata_eh_report(ap);
 
-       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_for_each_dev(dev, &ap->link, ALL)
+               struct ata_device *dev;
+
+               ata_for_each_dev(dev, link, ALL)
                        ata_dev_disable(dev);
        }
 
        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;
-
-       /* ignore built-in hardreset 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);
-}
 EXPORT_SYMBOL_GPL(ata_std_error_handler);
 
 #ifdef CONFIG_PM

diff --git a/drivers/ata/libata-sff.c b/drivers/ata/libata-sff.c
index 5a46c066abc3659787470de0b558c0972b238c0d..e61f00779e4087a62997909bad80f96ab5db2245 100644 (file)
--- a/drivers/ata/libata-sff.c
+++ b/drivers/ata/libata-sff.c
@@ -2054,8 +2054,6 @@ EXPORT_SYMBOL_GPL(ata_sff_drain_fifo);
  */
 void ata_sff_error_handler(struct ata_port *ap)
 {
-       ata_reset_fn_t softreset = ap->ops->softreset;
-       ata_reset_fn_t hardreset = ap->ops->hardreset;
        struct ata_queued_cmd *qc;
        unsigned long flags;
 
@@ -2077,13 +2075,7 @@ void ata_sff_error_handler(struct ata_port *ap)
 
        spin_unlock_irqrestore(ap->lock, flags);
 
-       /* ignore built-in hardresets if SCR access is not available */
-       if ((hardreset == sata_std_hardreset ||
-            hardreset == sata_sff_hardreset) && !sata_scr_valid(&ap->link))
-               hardreset = NULL;
-
-       ata_do_eh(ap, ap->ops->prereset, softreset, hardreset,
-                 ap->ops->postreset);
+       ata_std_error_handler(ap);
 }
 EXPORT_SYMBOL_GPL(ata_sff_error_handler);
 

diff --git a/include/linux/libata.h b/include/linux/libata.h
index d092747be5882714407ca3ff4ae85ee3bca8bd9f..cf0b3fff319808de59c3af7b0f36912ce953cb38 100644 (file)
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -1412,9 +1412,6 @@ extern void ata_eh_thaw_port(struct ata_port *ap);
 extern void ata_eh_qc_complete(struct ata_queued_cmd *qc);
 extern void ata_eh_qc_retry(struct ata_queued_cmd *qc);
 
-extern void ata_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);
 extern void ata_std_error_handler(struct ata_port *ap);
 extern void ata_std_sched_eh(struct ata_port *ap);
 extern void ata_std_end_eh(struct ata_port *ap);
@@ -2152,6 +2149,12 @@ static inline u8 ata_wait_idle(struct ata_port *ap)
 
        return status;
 }
+#else /* CONFIG_ATA_SFF */
+static inline int sata_sff_hardreset(struct ata_link *link, unsigned int *class,
+                                    unsigned long deadline)
+{
+       return -EOPNOTSUPP;
+}
 #endif /* CONFIG_ATA_SFF */
 
 #endif /* __LINUX_LIBATA_H__ */