LCOV - code coverage report
Current view: top level - drivers/ata - libata-eh.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 794 1613 49.2 %
Date: 2022-04-01 14:58:12 Functions: 55 78 70.5 %
Branches: 327 1180 27.7 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-or-later
       2                 :            : /*
       3                 :            :  *  libata-eh.c - libata error handling
       4                 :            :  *
       5                 :            :  *  Maintained by:  Tejun Heo <tj@kernel.org>
       6                 :            :  *                  Please ALWAYS copy linux-ide@vger.kernel.org
       7                 :            :  *                  on emails.
       8                 :            :  *
       9                 :            :  *  Copyright 2006 Tejun Heo <htejun@gmail.com>
      10                 :            :  *
      11                 :            :  *  libata documentation is available via 'make {ps|pdf}docs',
      12                 :            :  *  as Documentation/driver-api/libata.rst
      13                 :            :  *
      14                 :            :  *  Hardware documentation available from http://www.t13.org/ and
      15                 :            :  *  http://www.sata-io.org/
      16                 :            :  */
      17                 :            : 
      18                 :            : #include <linux/kernel.h>
      19                 :            : #include <linux/blkdev.h>
      20                 :            : #include <linux/export.h>
      21                 :            : #include <linux/pci.h>
      22                 :            : #include <scsi/scsi.h>
      23                 :            : #include <scsi/scsi_host.h>
      24                 :            : #include <scsi/scsi_eh.h>
      25                 :            : #include <scsi/scsi_device.h>
      26                 :            : #include <scsi/scsi_cmnd.h>
      27                 :            : #include <scsi/scsi_dbg.h>
      28                 :            : #include "../scsi/scsi_transport_api.h"
      29                 :            : 
      30                 :            : #include <linux/libata.h>
      31                 :            : 
      32                 :            : #include <trace/events/libata.h>
      33                 :            : #include "libata.h"
      34                 :            : 
      35                 :            : enum {
      36                 :            :         /* speed down verdicts */
      37                 :            :         ATA_EH_SPDN_NCQ_OFF             = (1 << 0),
      38                 :            :         ATA_EH_SPDN_SPEED_DOWN          = (1 << 1),
      39                 :            :         ATA_EH_SPDN_FALLBACK_TO_PIO     = (1 << 2),
      40                 :            :         ATA_EH_SPDN_KEEP_ERRORS         = (1 << 3),
      41                 :            : 
      42                 :            :         /* error flags */
      43                 :            :         ATA_EFLAG_IS_IO                 = (1 << 0),
      44                 :            :         ATA_EFLAG_DUBIOUS_XFER          = (1 << 1),
      45                 :            :         ATA_EFLAG_OLD_ER                = (1 << 31),
      46                 :            : 
      47                 :            :         /* error categories */
      48                 :            :         ATA_ECAT_NONE                   = 0,
      49                 :            :         ATA_ECAT_ATA_BUS                = 1,
      50                 :            :         ATA_ECAT_TOUT_HSM               = 2,
      51                 :            :         ATA_ECAT_UNK_DEV                = 3,
      52                 :            :         ATA_ECAT_DUBIOUS_NONE           = 4,
      53                 :            :         ATA_ECAT_DUBIOUS_ATA_BUS        = 5,
      54                 :            :         ATA_ECAT_DUBIOUS_TOUT_HSM       = 6,
      55                 :            :         ATA_ECAT_DUBIOUS_UNK_DEV        = 7,
      56                 :            :         ATA_ECAT_NR                     = 8,
      57                 :            : 
      58                 :            :         ATA_EH_CMD_DFL_TIMEOUT          =  5000,
      59                 :            : 
      60                 :            :         /* always put at least this amount of time between resets */
      61                 :            :         ATA_EH_RESET_COOL_DOWN          =  5000,
      62                 :            : 
      63                 :            :         /* Waiting in ->prereset can never be reliable.  It's
      64                 :            :          * sometimes nice to wait there but it can't be depended upon;
      65                 :            :          * otherwise, we wouldn't be resetting.  Just give it enough
      66                 :            :          * time for most drives to spin up.
      67                 :            :          */
      68                 :            :         ATA_EH_PRERESET_TIMEOUT         = 10000,
      69                 :            :         ATA_EH_FASTDRAIN_INTERVAL       =  3000,
      70                 :            : 
      71                 :            :         ATA_EH_UA_TRIES                 = 5,
      72                 :            : 
      73                 :            :         /* probe speed down parameters, see ata_eh_schedule_probe() */
      74                 :            :         ATA_EH_PROBE_TRIAL_INTERVAL     = 60000,        /* 1 min */
      75                 :            :         ATA_EH_PROBE_TRIALS             = 2,
      76                 :            : };
      77                 :            : 
      78                 :            : /* The following table determines how we sequence resets.  Each entry
      79                 :            :  * represents timeout for that try.  The first try can be soft or
      80                 :            :  * hardreset.  All others are hardreset if available.  In most cases
      81                 :            :  * the first reset w/ 10sec timeout should succeed.  Following entries
      82                 :            :  * are mostly for error handling, hotplug and those outlier devices that
      83                 :            :  * take an exceptionally long time to recover from reset.
      84                 :            :  */
      85                 :            : static const unsigned long ata_eh_reset_timeouts[] = {
      86                 :            :         10000,  /* most drives spin up by 10sec */
      87                 :            :         10000,  /* > 99% working drives spin up before 20sec */
      88                 :            :         35000,  /* give > 30 secs of idleness for outlier devices */
      89                 :            :          5000,  /* and sweet one last chance */
      90                 :            :         ULONG_MAX, /* > 1 min has elapsed, give up */
      91                 :            : };
      92                 :            : 
      93                 :            : static const unsigned long ata_eh_identify_timeouts[] = {
      94                 :            :          5000,  /* covers > 99% of successes and not too boring on failures */
      95                 :            :         10000,  /* combined time till here is enough even for media access */
      96                 :            :         30000,  /* for true idiots */
      97                 :            :         ULONG_MAX,
      98                 :            : };
      99                 :            : 
     100                 :            : static const unsigned long ata_eh_flush_timeouts[] = {
     101                 :            :         15000,  /* be generous with flush */
     102                 :            :         15000,  /* ditto */
     103                 :            :         30000,  /* and even more generous */
     104                 :            :         ULONG_MAX,
     105                 :            : };
     106                 :            : 
     107                 :            : static const unsigned long ata_eh_other_timeouts[] = {
     108                 :            :          5000,  /* same rationale as identify timeout */
     109                 :            :         10000,  /* ditto */
     110                 :            :         /* but no merciful 30sec for other commands, it just isn't worth it */
     111                 :            :         ULONG_MAX,
     112                 :            : };
     113                 :            : 
     114                 :            : struct ata_eh_cmd_timeout_ent {
     115                 :            :         const u8                *commands;
     116                 :            :         const unsigned long     *timeouts;
     117                 :            : };
     118                 :            : 
     119                 :            : /* The following table determines timeouts to use for EH internal
     120                 :            :  * commands.  Each table entry is a command class and matches the
     121                 :            :  * commands the entry applies to and the timeout table to use.
     122                 :            :  *
     123                 :            :  * On the retry after a command timed out, the next timeout value from
     124                 :            :  * the table is used.  If the table doesn't contain further entries,
     125                 :            :  * the last value is used.
     126                 :            :  *
     127                 :            :  * ehc->cmd_timeout_idx keeps track of which timeout to use per
     128                 :            :  * command class, so if SET_FEATURES times out on the first try, the
     129                 :            :  * next try will use the second timeout value only for that class.
     130                 :            :  */
     131                 :            : #define CMDS(cmds...)   (const u8 []){ cmds, 0 }
     132                 :            : static const struct ata_eh_cmd_timeout_ent
     133                 :            : ata_eh_cmd_timeout_table[ATA_EH_CMD_TIMEOUT_TABLE_SIZE] = {
     134                 :            :         { .commands = CMDS(ATA_CMD_ID_ATA, ATA_CMD_ID_ATAPI),
     135                 :            :           .timeouts = ata_eh_identify_timeouts, },
     136                 :            :         { .commands = CMDS(ATA_CMD_READ_NATIVE_MAX, ATA_CMD_READ_NATIVE_MAX_EXT),
     137                 :            :           .timeouts = ata_eh_other_timeouts, },
     138                 :            :         { .commands = CMDS(ATA_CMD_SET_MAX, ATA_CMD_SET_MAX_EXT),
     139                 :            :           .timeouts = ata_eh_other_timeouts, },
     140                 :            :         { .commands = CMDS(ATA_CMD_SET_FEATURES),
     141                 :            :           .timeouts = ata_eh_other_timeouts, },
     142                 :            :         { .commands = CMDS(ATA_CMD_INIT_DEV_PARAMS),
     143                 :            :           .timeouts = ata_eh_other_timeouts, },
     144                 :            :         { .commands = CMDS(ATA_CMD_FLUSH, ATA_CMD_FLUSH_EXT),
     145                 :            :           .timeouts = ata_eh_flush_timeouts },
     146                 :            : };
     147                 :            : #undef CMDS
     148                 :            : 
     149                 :            : static void __ata_port_freeze(struct ata_port *ap);
     150                 :            : #ifdef CONFIG_PM
     151                 :            : static void ata_eh_handle_port_suspend(struct ata_port *ap);
     152                 :            : static void ata_eh_handle_port_resume(struct ata_port *ap);
     153                 :            : #else /* CONFIG_PM */
     154                 :            : static void ata_eh_handle_port_suspend(struct ata_port *ap)
     155                 :            : { }
     156                 :            : 
     157                 :            : static void ata_eh_handle_port_resume(struct ata_port *ap)
     158                 :            : { }
     159                 :            : #endif /* CONFIG_PM */
     160                 :            : 
     161                 :         33 : static __printf(2, 0) void __ata_ehi_pushv_desc(struct ata_eh_info *ehi,
     162                 :            :                                  const char *fmt, va_list args)
     163                 :            : {
     164                 :         66 :         ehi->desc_len += vscnprintf(ehi->desc + ehi->desc_len,
     165                 :         33 :                                      ATA_EH_DESC_LEN - ehi->desc_len,
     166                 :            :                                      fmt, args);
     167                 :            : }
     168                 :            : 
     169                 :            : /**
     170                 :            :  *      __ata_ehi_push_desc - push error description without adding separator
     171                 :            :  *      @ehi: target EHI
     172                 :            :  *      @fmt: printf format string
     173                 :            :  *
     174                 :            :  *      Format string according to @fmt and append it to @ehi->desc.
     175                 :            :  *
     176                 :            :  *      LOCKING:
     177                 :            :  *      spin_lock_irqsave(host lock)
     178                 :            :  */
     179                 :         12 : void __ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
     180                 :            : {
     181                 :         12 :         va_list args;
     182                 :            : 
     183                 :         12 :         va_start(args, fmt);
     184                 :         12 :         __ata_ehi_pushv_desc(ehi, fmt, args);
     185                 :         12 :         va_end(args);
     186                 :         12 : }
     187                 :            : 
     188                 :            : /**
     189                 :            :  *      ata_ehi_push_desc - push error description with separator
     190                 :            :  *      @ehi: target EHI
     191                 :            :  *      @fmt: printf format string
     192                 :            :  *
     193                 :            :  *      Format string according to @fmt and append it to @ehi->desc.
     194                 :            :  *      If @ehi->desc is not empty, ", " is added in-between.
     195                 :            :  *
     196                 :            :  *      LOCKING:
     197                 :            :  *      spin_lock_irqsave(host lock)
     198                 :            :  */
     199                 :          3 : void ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
     200                 :            : {
     201                 :          3 :         va_list args;
     202                 :            : 
     203         [ -  + ]:          3 :         if (ehi->desc_len)
     204                 :          0 :                 __ata_ehi_push_desc(ehi, ", ");
     205                 :            : 
     206                 :          3 :         va_start(args, fmt);
     207                 :          3 :         __ata_ehi_pushv_desc(ehi, fmt, args);
     208                 :          3 :         va_end(args);
     209                 :          3 : }
     210                 :            : 
     211                 :            : /**
     212                 :            :  *      ata_ehi_clear_desc - clean error description
     213                 :            :  *      @ehi: target EHI
     214                 :            :  *
     215                 :            :  *      Clear @ehi->desc.
     216                 :            :  *
     217                 :            :  *      LOCKING:
     218                 :            :  *      spin_lock_irqsave(host lock)
     219                 :            :  */
     220                 :          6 : void ata_ehi_clear_desc(struct ata_eh_info *ehi)
     221                 :            : {
     222                 :          6 :         ehi->desc[0] = '\0';
     223                 :          6 :         ehi->desc_len = 0;
     224                 :          6 : }
     225                 :            : 
     226                 :            : /**
     227                 :            :  *      ata_port_desc - append port description
     228                 :            :  *      @ap: target ATA port
     229                 :            :  *      @fmt: printf format string
     230                 :            :  *
     231                 :            :  *      Format string according to @fmt and append it to port
     232                 :            :  *      description.  If port description is not empty, " " is added
     233                 :            :  *      in-between.  This function is to be used while initializing
     234                 :            :  *      ata_host.  The description is printed on host registration.
     235                 :            :  *
     236                 :            :  *      LOCKING:
     237                 :            :  *      None.
     238                 :            :  */
     239                 :         18 : void ata_port_desc(struct ata_port *ap, const char *fmt, ...)
     240                 :            : {
     241                 :         18 :         va_list args;
     242                 :            : 
     243         [ -  + ]:         18 :         WARN_ON(!(ap->pflags & ATA_PFLAG_INITIALIZING));
     244                 :            : 
     245         [ +  + ]:         18 :         if (ap->link.eh_info.desc_len)
     246                 :         12 :                 __ata_ehi_push_desc(&ap->link.eh_info, " ");
     247                 :            : 
     248                 :         18 :         va_start(args, fmt);
     249                 :         18 :         __ata_ehi_pushv_desc(&ap->link.eh_info, fmt, args);
     250                 :         18 :         va_end(args);
     251                 :         18 : }
     252                 :            : 
     253                 :            : #ifdef CONFIG_PCI
     254                 :            : 
     255                 :            : /**
     256                 :            :  *      ata_port_pbar_desc - append PCI BAR description
     257                 :            :  *      @ap: target ATA port
     258                 :            :  *      @bar: target PCI BAR
     259                 :            :  *      @offset: offset into PCI BAR
     260                 :            :  *      @name: name of the area
     261                 :            :  *
     262                 :            :  *      If @offset is negative, this function formats a string which
     263                 :            :  *      contains the name, address, size and type of the BAR and
     264                 :            :  *      appends it to the port description.  If @offset is zero or
     265                 :            :  *      positive, only name and offsetted address is appended.
     266                 :            :  *
     267                 :            :  *      LOCKING:
     268                 :            :  *      None.
     269                 :            :  */
     270                 :          0 : void ata_port_pbar_desc(struct ata_port *ap, int bar, ssize_t offset,
     271                 :            :                         const char *name)
     272                 :            : {
     273                 :          0 :         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
     274                 :          0 :         char *type = "";
     275                 :          0 :         unsigned long long start, len;
     276                 :            : 
     277         [ #  # ]:          0 :         if (pci_resource_flags(pdev, bar) & IORESOURCE_MEM)
     278                 :            :                 type = "m";
     279         [ #  # ]:          0 :         else if (pci_resource_flags(pdev, bar) & IORESOURCE_IO)
     280                 :          0 :                 type = "i";
     281                 :            : 
     282                 :          0 :         start = (unsigned long long)pci_resource_start(pdev, bar);
     283   [ #  #  #  # ]:          0 :         len = (unsigned long long)pci_resource_len(pdev, bar);
     284                 :            : 
     285         [ #  # ]:          0 :         if (offset < 0)
     286                 :          0 :                 ata_port_desc(ap, "%s %s%llu@0x%llx", name, type, len, start);
     287                 :            :         else
     288                 :          0 :                 ata_port_desc(ap, "%s 0x%llx", name,
     289                 :          0 :                                 start + (unsigned long long)offset);
     290                 :          0 : }
     291                 :            : 
     292                 :            : #endif /* CONFIG_PCI */
     293                 :            : 
     294                 :         53 : static int ata_lookup_timeout_table(u8 cmd)
     295                 :            : {
     296                 :         53 :         int i;
     297                 :            : 
     298   [ -  -  +  + ]:        245 :         for (i = 0; i < ATA_EH_CMD_TIMEOUT_TABLE_SIZE; i++) {
     299                 :        213 :                 const u8 *cur;
     300                 :            : 
     301   [ -  -  +  + ]:        539 :                 for (cur = ata_eh_cmd_timeout_table[i].commands; *cur; cur++)
     302   [ -  -  +  + ]:        347 :                         if (*cur == cmd)
     303                 :            :                                 return i;
     304                 :            :         }
     305                 :            : 
     306                 :            :         return -1;
     307                 :            : }
     308                 :            : 
     309                 :            : /**
     310                 :            :  *      ata_internal_cmd_timeout - determine timeout for an internal command
     311                 :            :  *      @dev: target device
     312                 :            :  *      @cmd: internal command to be issued
     313                 :            :  *
     314                 :            :  *      Determine timeout for internal command @cmd for @dev.
     315                 :            :  *
     316                 :            :  *      LOCKING:
     317                 :            :  *      EH context.
     318                 :            :  *
     319                 :            :  *      RETURNS:
     320                 :            :  *      Determined timeout.
     321                 :            :  */
     322                 :         53 : unsigned long ata_internal_cmd_timeout(struct ata_device *dev, u8 cmd)
     323                 :            : {
     324                 :         53 :         struct ata_eh_context *ehc = &dev->link->eh_context;
     325                 :         53 :         int ent = ata_lookup_timeout_table(cmd);
     326                 :         53 :         int idx;
     327                 :            : 
     328         [ +  + ]:         53 :         if (ent < 0)
     329                 :            :                 return ATA_EH_CMD_DFL_TIMEOUT;
     330                 :            : 
     331                 :         21 :         idx = ehc->cmd_timeout_idx[dev->devno][ent];
     332                 :         21 :         return ata_eh_cmd_timeout_table[ent].timeouts[idx];
     333                 :            : }
     334                 :            : 
     335                 :            : /**
     336                 :            :  *      ata_internal_cmd_timed_out - notification for internal command timeout
     337                 :            :  *      @dev: target device
     338                 :            :  *      @cmd: internal command which timed out
     339                 :            :  *
     340                 :            :  *      Notify EH that internal command @cmd for @dev timed out.  This
     341                 :            :  *      function should be called only for commands whose timeouts are
     342                 :            :  *      determined using ata_internal_cmd_timeout().
     343                 :            :  *
     344                 :            :  *      LOCKING:
     345                 :            :  *      EH context.
     346                 :            :  */
     347                 :          0 : void ata_internal_cmd_timed_out(struct ata_device *dev, u8 cmd)
     348                 :            : {
     349                 :          0 :         struct ata_eh_context *ehc = &dev->link->eh_context;
     350                 :          0 :         int ent = ata_lookup_timeout_table(cmd);
     351                 :          0 :         int idx;
     352                 :            : 
     353         [ #  # ]:          0 :         if (ent < 0)
     354                 :            :                 return;
     355                 :            : 
     356                 :          0 :         idx = ehc->cmd_timeout_idx[dev->devno][ent];
     357         [ #  # ]:          0 :         if (ata_eh_cmd_timeout_table[ent].timeouts[idx + 1] != ULONG_MAX)
     358                 :          0 :                 ehc->cmd_timeout_idx[dev->devno][ent]++;
     359                 :            : }
     360                 :            : 
     361                 :         12 : static void ata_ering_record(struct ata_ering *ering, unsigned int eflags,
     362                 :            :                              unsigned int err_mask)
     363                 :            : {
     364                 :         12 :         struct ata_ering_entry *ent;
     365                 :            : 
     366                 :          0 :         WARN_ON(!err_mask);
     367                 :            : 
     368                 :         12 :         ering->cursor++;
     369                 :         12 :         ering->cursor %= ATA_ERING_SIZE;
     370                 :            : 
     371                 :         12 :         ent = &ering->ring[ering->cursor];
     372                 :         12 :         ent->eflags = eflags;
     373                 :         12 :         ent->err_mask = err_mask;
     374                 :          0 :         ent->timestamp = get_jiffies_64();
     375                 :            : }
     376                 :            : 
     377                 :          9 : static struct ata_ering_entry *ata_ering_top(struct ata_ering *ering)
     378                 :            : {
     379                 :          9 :         struct ata_ering_entry *ent = &ering->ring[ering->cursor];
     380                 :            : 
     381                 :          9 :         if (ent->err_mask)
     382                 :          9 :                 return ent;
     383                 :            :         return NULL;
     384                 :            : }
     385                 :            : 
     386                 :         21 : int ata_ering_map(struct ata_ering *ering,
     387                 :            :                   int (*map_fn)(struct ata_ering_entry *, void *),
     388                 :            :                   void *arg)
     389                 :            : {
     390                 :         21 :         int idx, rc = 0;
     391                 :         21 :         struct ata_ering_entry *ent;
     392                 :            : 
     393                 :          0 :         idx = ering->cursor;
     394                 :         42 :         do {
     395                 :         42 :                 ent = &ering->ring[idx];
     396   [ +  +  -  -  :         42 :                 if (!ent->err_mask)
          -  -  +  +  -  
                      - ]
     397                 :            :                         break;
     398                 :         21 :                 rc = map_fn(ent, arg);
     399   [ +  -  -  -  :         21 :                 if (rc)
          -  -  +  -  -  
                      - ]
     400                 :            :                         break;
     401                 :         21 :                 idx = (idx - 1 + ATA_ERING_SIZE) % ATA_ERING_SIZE;
     402   [ +  -  -  -  :         21 :         } while (idx != ering->cursor);
          -  -  +  -  -  
                      - ]
     403                 :            : 
     404                 :         21 :         return rc;
     405                 :            : }
     406                 :            : 
     407                 :          9 : static int ata_ering_clear_cb(struct ata_ering_entry *ent, void *void_arg)
     408                 :            : {
     409                 :          9 :         ent->eflags |= ATA_EFLAG_OLD_ER;
     410                 :          9 :         return 0;
     411                 :            : }
     412                 :            : 
     413                 :          9 : static void ata_ering_clear(struct ata_ering *ering)
     414                 :            : {
     415                 :          9 :         ata_ering_map(ering, ata_ering_clear_cb, NULL);
     416                 :          9 : }
     417                 :            : 
     418                 :         76 : static unsigned int ata_eh_dev_action(struct ata_device *dev)
     419                 :            : {
     420                 :         76 :         struct ata_eh_context *ehc = &dev->link->eh_context;
     421                 :            : 
     422                 :         76 :         return ehc->i.action | ehc->i.dev_action[dev->devno];
     423                 :            : }
     424                 :            : 
     425                 :        112 : static void ata_eh_clear_action(struct ata_link *link, struct ata_device *dev,
     426                 :            :                                 struct ata_eh_info *ehi, unsigned int action)
     427                 :            : {
     428                 :        112 :         struct ata_device *tdev;
     429                 :            : 
     430         [ +  + ]:        112 :         if (!dev) {
     431                 :         12 :                 ehi->action &= ~action;
     432         [ +  + ]:         36 :                 ata_for_each_dev(tdev, link, ALL)
     433                 :         24 :                         ehi->dev_action[tdev->devno] &= ~action;
     434                 :            :         } else {
     435                 :            :                 /* doesn't make sense for port-wide EH actions */
     436         [ -  + ]:        100 :                 WARN_ON(!(action & ATA_EH_PERDEV_MASK));
     437                 :            : 
     438                 :            :                 /* break ehi->action into ehi->dev_action */
     439         [ -  + ]:        100 :                 if (ehi->action & action) {
     440         [ #  # ]:          0 :                         ata_for_each_dev(tdev, link, ALL)
     441                 :          0 :                                 ehi->dev_action[tdev->devno] |=
     442                 :          0 :                                         ehi->action & action;
     443                 :          0 :                         ehi->action &= ~action;
     444                 :            :                 }
     445                 :            : 
     446                 :            :                 /* turn off the specified per-dev action */
     447                 :        100 :                 ehi->dev_action[dev->devno] &= ~action;
     448                 :            :         }
     449                 :        112 : }
     450                 :            : 
     451                 :            : /**
     452                 :            :  *      ata_eh_acquire - acquire EH ownership
     453                 :            :  *      @ap: ATA port to acquire EH ownership for
     454                 :            :  *
     455                 :            :  *      Acquire EH ownership for @ap.  This is the basic exclusion
     456                 :            :  *      mechanism for ports sharing a host.  Only one port hanging off
     457                 :            :  *      the same host can claim the ownership of EH.
     458                 :            :  *
     459                 :            :  *      LOCKING:
     460                 :            :  *      EH context.
     461                 :            :  */
     462                 :        103 : void ata_eh_acquire(struct ata_port *ap)
     463                 :            : {
     464                 :        103 :         mutex_lock(&ap->host->eh_mutex);
     465         [ -  + ]:        103 :         WARN_ON_ONCE(ap->host->eh_owner);
     466                 :        103 :         ap->host->eh_owner = current;
     467                 :        103 : }
     468                 :            : 
     469                 :            : /**
     470                 :            :  *      ata_eh_release - release EH ownership
     471                 :            :  *      @ap: ATA port to release EH ownership for
     472                 :            :  *
     473                 :            :  *      Release EH ownership for @ap if the caller.  The caller must
     474                 :            :  *      have acquired EH ownership using ata_eh_acquire() previously.
     475                 :            :  *
     476                 :            :  *      LOCKING:
     477                 :            :  *      EH context.
     478                 :            :  */
     479                 :        103 : void ata_eh_release(struct ata_port *ap)
     480                 :            : {
     481         [ -  + ]:        103 :         WARN_ON_ONCE(ap->host->eh_owner != current);
     482                 :        103 :         ap->host->eh_owner = NULL;
     483                 :        103 :         mutex_unlock(&ap->host->eh_mutex);
     484                 :        103 : }
     485                 :            : 
     486                 :          0 : static void ata_eh_unload(struct ata_port *ap)
     487                 :            : {
     488                 :          0 :         struct ata_link *link;
     489                 :          0 :         struct ata_device *dev;
     490                 :          0 :         unsigned long flags;
     491                 :            : 
     492                 :            :         /* Restore SControl IPM and SPD for the next driver and
     493                 :            :          * disable attached devices.
     494                 :            :          */
     495         [ #  # ]:          0 :         ata_for_each_link(link, ap, PMP_FIRST) {
     496                 :          0 :                 sata_scr_write(link, SCR_CONTROL, link->saved_scontrol & 0xff0);
     497         [ #  # ]:          0 :                 ata_for_each_dev(dev, link, ALL)
     498                 :          0 :                         ata_dev_disable(dev);
     499                 :            :         }
     500                 :            : 
     501                 :            :         /* freeze and set UNLOADED */
     502                 :          0 :         spin_lock_irqsave(ap->lock, flags);
     503                 :            : 
     504                 :          0 :         ata_port_freeze(ap);                    /* won't be thawed */
     505                 :          0 :         ap->pflags &= ~ATA_PFLAG_EH_PENDING;     /* clear pending from freeze */
     506                 :          0 :         ap->pflags |= ATA_PFLAG_UNLOADED;
     507                 :            : 
     508                 :          0 :         spin_unlock_irqrestore(ap->lock, flags);
     509                 :          0 : }
     510                 :            : 
     511                 :            : /**
     512                 :            :  *      ata_scsi_error - SCSI layer error handler callback
     513                 :            :  *      @host: SCSI host on which error occurred
     514                 :            :  *
     515                 :            :  *      Handles SCSI-layer-thrown error events.
     516                 :            :  *
     517                 :            :  *      LOCKING:
     518                 :            :  *      Inherited from SCSI layer (none, can sleep)
     519                 :            :  *
     520                 :            :  *      RETURNS:
     521                 :            :  *      Zero.
     522                 :            :  */
     523                 :         35 : void ata_scsi_error(struct Scsi_Host *host)
     524                 :            : {
     525                 :         35 :         struct ata_port *ap = ata_shost_to_port(host);
     526                 :         35 :         unsigned long flags;
     527                 :         35 :         LIST_HEAD(eh_work_q);
     528                 :            : 
     529                 :         35 :         DPRINTK("ENTER\n");
     530                 :            : 
     531                 :         35 :         spin_lock_irqsave(host->host_lock, flags);
     532         [ +  + ]:         35 :         list_splice_init(&host->eh_cmd_q, &eh_work_q);
     533                 :         35 :         spin_unlock_irqrestore(host->host_lock, flags);
     534                 :            : 
     535                 :         35 :         ata_scsi_cmd_error_handler(host, ap, &eh_work_q);
     536                 :            : 
     537                 :            :         /* If we timed raced normal completion and there is nothing to
     538                 :            :            recover nr_timedout == 0 why exactly are we doing error recovery ? */
     539                 :         35 :         ata_scsi_port_error_handler(host, ap);
     540                 :            : 
     541                 :            :         /* finish or retry handled scmd's and clean up */
     542         [ -  + ]:         35 :         WARN_ON(!list_empty(&eh_work_q));
     543                 :            : 
     544                 :         35 :         DPRINTK("EXIT\n");
     545                 :         35 : }
     546                 :            : 
     547                 :            : /**
     548                 :            :  * ata_scsi_cmd_error_handler - error callback for a list of commands
     549                 :            :  * @host:       scsi host containing the port
     550                 :            :  * @ap:         ATA port within the host
     551                 :            :  * @eh_work_q:  list of commands to process
     552                 :            :  *
     553                 :            :  * process the given list of commands and return those finished to the
     554                 :            :  * ap->eh_done_q.  This function is the first part of the libata error
     555                 :            :  * handler which processes a given list of failed commands.
     556                 :            :  */
     557                 :         35 : void ata_scsi_cmd_error_handler(struct Scsi_Host *host, struct ata_port *ap,
     558                 :            :                                 struct list_head *eh_work_q)
     559                 :            : {
     560                 :         35 :         int i;
     561                 :         35 :         unsigned long flags;
     562                 :            : 
     563                 :            :         /* make sure sff pio task is not running */
     564                 :         35 :         ata_sff_flush_pio_task(ap);
     565                 :            : 
     566                 :            :         /* synchronize with host lock and sort out timeouts */
     567                 :            : 
     568                 :            :         /* For new EH, all qcs are finished in one of three ways -
     569                 :            :          * normal completion, error completion, and SCSI timeout.
     570                 :            :          * Both completions can race against SCSI timeout.  When normal
     571                 :            :          * completion wins, the qc never reaches EH.  When error
     572                 :            :          * completion wins, the qc has ATA_QCFLAG_FAILED set.
     573                 :            :          *
     574                 :            :          * When SCSI timeout wins, things are a bit more complex.
     575                 :            :          * Normal or error completion can occur after the timeout but
     576                 :            :          * before this point.  In such cases, both types of
     577                 :            :          * completions are honored.  A scmd is determined to have
     578                 :            :          * timed out iff its associated qc is active and not failed.
     579                 :            :          */
     580                 :         35 :         spin_lock_irqsave(ap->lock, flags);
     581         [ +  - ]:         35 :         if (ap->ops->error_handler) {
     582                 :         35 :                 struct scsi_cmnd *scmd, *tmp;
     583                 :         35 :                 int nr_timedout = 0;
     584                 :            : 
     585                 :            :                 /* This must occur under the ap->lock as we don't want
     586                 :            :                    a polled recovery to race the real interrupt handler
     587                 :            : 
     588                 :            :                    The lost_interrupt handler checks for any completed but
     589                 :            :                    non-notified command and completes much like an IRQ handler.
     590                 :            : 
     591                 :            :                    We then fall into the error recovery code which will treat
     592                 :            :                    this as if normal completion won the race */
     593                 :            : 
     594         [ +  - ]:         35 :                 if (ap->ops->lost_interrupt)
     595                 :         35 :                         ap->ops->lost_interrupt(ap);
     596                 :            : 
     597         [ +  + ]:         64 :                 list_for_each_entry_safe(scmd, tmp, eh_work_q, eh_entry) {
     598                 :            :                         struct ata_queued_cmd *qc;
     599                 :            : 
     600   [ +  -  +  - ]:         29 :                         ata_qc_for_each_raw(ap, qc, i) {
     601         [ +  - ]:         29 :                                 if (qc->flags & ATA_QCFLAG_ACTIVE &&
     602         [ -  + ]:         29 :                                     qc->scsicmd == scmd)
     603                 :            :                                         break;
     604                 :            :                         }
     605                 :            : 
     606         [ +  - ]:         29 :                         if (i < ATA_MAX_QUEUE) {
     607                 :            :                                 /* the scmd has an associated qc */
     608         [ -  + ]:         29 :                                 if (!(qc->flags & ATA_QCFLAG_FAILED)) {
     609                 :            :                                         /* which hasn't failed yet, timeout */
     610                 :          0 :                                         qc->err_mask |= AC_ERR_TIMEOUT;
     611                 :          0 :                                         qc->flags |= ATA_QCFLAG_FAILED;
     612                 :          0 :                                         nr_timedout++;
     613                 :            :                                 }
     614                 :            :                         } else {
     615                 :            :                                 /* Normal completion occurred after
     616                 :            :                                  * SCSI timeout but before this point.
     617                 :            :                                  * Successfully complete it.
     618                 :            :                                  */
     619                 :          0 :                                 scmd->retries = scmd->allowed;
     620                 :          0 :                                 scsi_eh_finish_cmd(scmd, &ap->eh_done_q);
     621                 :            :                         }
     622                 :            :                 }
     623                 :            : 
     624                 :            :                 /* If we have timed out qcs.  They belong to EH from
     625                 :            :                  * this point but the state of the controller is
     626                 :            :                  * unknown.  Freeze the port to make sure the IRQ
     627                 :            :                  * handler doesn't diddle with those qcs.  This must
     628                 :            :                  * be done atomically w.r.t. setting QCFLAG_FAILED.
     629                 :            :                  */
     630         [ -  + ]:         35 :                 if (nr_timedout)
     631                 :          0 :                         __ata_port_freeze(ap);
     632                 :            : 
     633                 :            : 
     634                 :            :                 /* initialize eh_tries */
     635                 :         35 :                 ap->eh_tries = ATA_EH_MAX_TRIES;
     636                 :            :         }
     637                 :         35 :         spin_unlock_irqrestore(ap->lock, flags);
     638                 :            : 
     639                 :         35 : }
     640                 :            : EXPORT_SYMBOL(ata_scsi_cmd_error_handler);
     641                 :            : 
     642                 :            : /**
     643                 :            :  * ata_scsi_port_error_handler - recover the port after the commands
     644                 :            :  * @host:       SCSI host containing the port
     645                 :            :  * @ap:         the ATA port
     646                 :            :  *
     647                 :            :  * Handle the recovery of the port @ap after all the commands
     648                 :            :  * have been recovered.
     649                 :            :  */
     650                 :         35 : void ata_scsi_port_error_handler(struct Scsi_Host *host, struct ata_port *ap)
     651                 :            : {
     652                 :         35 :         unsigned long flags;
     653                 :            : 
     654                 :            :         /* invoke error handler */
     655         [ +  - ]:         35 :         if (ap->ops->error_handler) {
     656                 :         35 :                 struct ata_link *link;
     657                 :            : 
     658                 :            :                 /* acquire EH ownership */
     659                 :         35 :                 ata_eh_acquire(ap);
     660                 :         38 :  repeat:
     661                 :            :                 /* kill fast drain timer */
     662                 :         38 :                 del_timer_sync(&ap->fastdrain_timer);
     663                 :            : 
     664                 :            :                 /* process port resume request */
     665                 :         38 :                 ata_eh_handle_port_resume(ap);
     666                 :            : 
     667                 :            :                 /* fetch & clear EH info */
     668                 :         38 :                 spin_lock_irqsave(ap->lock, flags);
     669                 :            : 
     670         [ +  + ]:         76 :                 ata_for_each_link(link, ap, HOST_FIRST) {
     671                 :         38 :                         struct ata_eh_context *ehc = &link->eh_context;
     672                 :         38 :                         struct ata_device *dev;
     673                 :            : 
     674                 :         38 :                         memset(&link->eh_context, 0, sizeof(link->eh_context));
     675                 :         38 :                         link->eh_context.i = link->eh_info;
     676                 :         38 :                         memset(&link->eh_info, 0, sizeof(link->eh_info));
     677                 :            : 
     678         [ +  + ]:         70 :                         ata_for_each_dev(dev, link, ENABLED) {
     679                 :         32 :                                 int devno = dev->devno;
     680                 :            : 
     681                 :         32 :                                 ehc->saved_xfer_mode[devno] = dev->xfer_mode;
     682         [ -  + ]:         32 :                                 if (ata_ncq_enabled(dev))
     683                 :          0 :                                         ehc->saved_ncq_enabled |= 1 << devno;
     684                 :            :                         }
     685                 :            :                 }
     686                 :            : 
     687                 :         38 :                 ap->pflags |= ATA_PFLAG_EH_IN_PROGRESS;
     688                 :         38 :                 ap->pflags &= ~ATA_PFLAG_EH_PENDING;
     689                 :         38 :                 ap->excl_link = NULL;        /* don't maintain exclusion over EH */
     690                 :            : 
     691                 :         38 :                 spin_unlock_irqrestore(ap->lock, flags);
     692                 :            : 
     693                 :            :                 /* invoke EH, skip if unloading or suspended */
     694         [ +  - ]:         38 :                 if (!(ap->pflags & (ATA_PFLAG_UNLOADING | ATA_PFLAG_SUSPENDED)))
     695                 :         38 :                         ap->ops->error_handler(ap);
     696                 :            :                 else {
     697                 :            :                         /* if unloading, commence suicide */
     698         [ #  # ]:          0 :                         if ((ap->pflags & ATA_PFLAG_UNLOADING) &&
     699                 :            :                             !(ap->pflags & ATA_PFLAG_UNLOADED))
     700                 :          0 :                                 ata_eh_unload(ap);
     701                 :          0 :                         ata_eh_finish(ap);
     702                 :            :                 }
     703                 :            : 
     704                 :            :                 /* process port suspend request */
     705                 :         38 :                 ata_eh_handle_port_suspend(ap);
     706                 :            : 
     707                 :            :                 /* Exception might have happened after ->error_handler
     708                 :            :                  * recovered the port but before this point.  Repeat
     709                 :            :                  * EH in such case.
     710                 :            :                  */
     711                 :         38 :                 spin_lock_irqsave(ap->lock, flags);
     712                 :            : 
     713         [ +  + ]:         38 :                 if (ap->pflags & ATA_PFLAG_EH_PENDING) {
     714         [ +  - ]:          3 :                         if (--ap->eh_tries) {
     715                 :          3 :                                 spin_unlock_irqrestore(ap->lock, flags);
     716                 :          3 :                                 goto repeat;
     717                 :            :                         }
     718                 :          0 :                         ata_port_err(ap,
     719                 :            :                                      "EH pending after %d tries, giving up\n",
     720                 :            :                                      ATA_EH_MAX_TRIES);
     721                 :          0 :                         ap->pflags &= ~ATA_PFLAG_EH_PENDING;
     722                 :            :                 }
     723                 :            : 
     724                 :            :                 /* this run is complete, make sure EH info is clear */
     725         [ +  + ]:         70 :                 ata_for_each_link(link, ap, HOST_FIRST)
     726                 :         35 :                         memset(&link->eh_info, 0, sizeof(link->eh_info));
     727                 :            : 
     728                 :            :                 /* end eh (clear host_eh_scheduled) while holding
     729                 :            :                  * ap->lock such that if exception occurs after this
     730                 :            :                  * point but before EH completion, SCSI midlayer will
     731                 :            :                  * re-initiate EH.
     732                 :            :                  */
     733                 :         35 :                 ap->ops->end_eh(ap);
     734                 :            : 
     735                 :         35 :                 spin_unlock_irqrestore(ap->lock, flags);
     736                 :         35 :                 ata_eh_release(ap);
     737                 :            :         } else {
     738   [ #  #  #  # ]:          0 :                 WARN_ON(ata_qc_from_tag(ap, ap->link.active_tag) == NULL);
     739                 :          0 :                 ap->ops->eng_timeout(ap);
     740                 :            :         }
     741                 :            : 
     742                 :         35 :         scsi_eh_flush_done_q(&ap->eh_done_q);
     743                 :            : 
     744                 :            :         /* clean up */
     745                 :         35 :         spin_lock_irqsave(ap->lock, flags);
     746                 :            : 
     747         [ +  + ]:         35 :         if (ap->pflags & ATA_PFLAG_LOADING)
     748                 :          6 :                 ap->pflags &= ~ATA_PFLAG_LOADING;
     749         [ -  + ]:         29 :         else if ((ap->pflags & ATA_PFLAG_SCSI_HOTPLUG) &&
     750         [ #  # ]:          0 :                 !(ap->flags & ATA_FLAG_SAS_HOST))
     751                 :          0 :                 schedule_delayed_work(&ap->hotplug_task, 0);
     752                 :            : 
     753         [ -  + ]:         35 :         if (ap->pflags & ATA_PFLAG_RECOVERED)
     754                 :          0 :                 ata_port_info(ap, "EH complete\n");
     755                 :            : 
     756                 :         35 :         ap->pflags &= ~(ATA_PFLAG_SCSI_HOTPLUG | ATA_PFLAG_RECOVERED);
     757                 :            : 
     758                 :            :         /* tell wait_eh that we're done */
     759                 :         35 :         ap->pflags &= ~ATA_PFLAG_EH_IN_PROGRESS;
     760                 :         35 :         wake_up_all(&ap->eh_wait_q);
     761                 :            : 
     762                 :         35 :         spin_unlock_irqrestore(ap->lock, flags);
     763                 :         35 : }
     764                 :            : EXPORT_SYMBOL_GPL(ata_scsi_port_error_handler);
     765                 :            : 
     766                 :            : /**
     767                 :            :  *      ata_port_wait_eh - Wait for the currently pending EH to complete
     768                 :            :  *      @ap: Port to wait EH for
     769                 :            :  *
     770                 :            :  *      Wait until the currently pending EH is complete.
     771                 :            :  *
     772                 :            :  *      LOCKING:
     773                 :            :  *      Kernel thread context (may sleep).
     774                 :            :  */
     775                 :          6 : void ata_port_wait_eh(struct ata_port *ap)
     776                 :            : {
     777                 :          6 :         unsigned long flags;
     778                 :          6 :         DEFINE_WAIT(wait);
     779                 :            : 
     780                 :          6 :  retry:
     781                 :          6 :         spin_lock_irqsave(ap->lock, flags);
     782                 :            : 
     783                 :          6 :         while (ap->pflags & (ATA_PFLAG_EH_PENDING | ATA_PFLAG_EH_IN_PROGRESS)) {
     784                 :          6 :                 prepare_to_wait(&ap->eh_wait_q, &wait, TASK_UNINTERRUPTIBLE);
     785                 :          6 :                 spin_unlock_irqrestore(ap->lock, flags);
     786                 :          6 :                 schedule();
     787         [ +  + ]:         12 :                 spin_lock_irqsave(ap->lock, flags);
     788                 :            :         }
     789                 :          6 :         finish_wait(&ap->eh_wait_q, &wait);
     790                 :            : 
     791                 :          6 :         spin_unlock_irqrestore(ap->lock, flags);
     792                 :            : 
     793                 :            :         /* make sure SCSI EH is complete */
     794         [ +  - ]:          6 :         if (scsi_host_in_recovery(ap->scsi_host)) {
     795                 :          0 :                 ata_msleep(ap, 10);
     796                 :          0 :                 goto retry;
     797                 :            :         }
     798                 :          6 : }
     799                 :            : EXPORT_SYMBOL_GPL(ata_port_wait_eh);
     800                 :            : 
     801                 :          0 : static int ata_eh_nr_in_flight(struct ata_port *ap)
     802                 :            : {
     803                 :            :         struct ata_queued_cmd *qc;
     804                 :            :         unsigned int tag;
     805                 :            :         int nr = 0;
     806                 :            : 
     807                 :            :         /* count only non-internal commands */
     808   [ +  +  +  -  :       1155 :         ata_qc_for_each(ap, qc, tag) {
             -  -  -  - ]
     809   [ #  #  #  # ]:          0 :                 if (qc)
     810                 :          0 :                         nr++;
     811                 :            :         }
     812                 :            : 
     813                 :         35 :         return nr;
     814                 :            : }
     815                 :            : 
     816                 :          0 : void ata_eh_fastdrain_timerfn(struct timer_list *t)
     817                 :            : {
     818                 :          0 :         struct ata_port *ap = from_timer(ap, t, fastdrain_timer);
     819                 :          0 :         unsigned long flags;
     820                 :          0 :         int cnt;
     821                 :            : 
     822                 :          0 :         spin_lock_irqsave(ap->lock, flags);
     823                 :            : 
     824                 :          0 :         cnt = ata_eh_nr_in_flight(ap);
     825                 :            : 
     826                 :            :         /* are we done? */
     827         [ #  # ]:          0 :         if (!cnt)
     828                 :          0 :                 goto out_unlock;
     829                 :            : 
     830         [ #  # ]:          0 :         if (cnt == ap->fastdrain_cnt) {
     831                 :            :                 struct ata_queued_cmd *qc;
     832                 :            :                 unsigned int tag;
     833                 :            : 
     834                 :            :                 /* No progress during the last interval, tag all
     835                 :            :                  * in-flight qcs as timed out and freeze the port.
     836                 :            :                  */
     837   [ #  #  #  # ]:          0 :                 ata_qc_for_each(ap, qc, tag) {
     838         [ #  # ]:          0 :                         if (qc)
     839                 :          0 :                                 qc->err_mask |= AC_ERR_TIMEOUT;
     840                 :            :                 }
     841                 :            : 
     842                 :          0 :                 ata_port_freeze(ap);
     843                 :            :         } else {
     844                 :            :                 /* some qcs have finished, give it another chance */
     845                 :          0 :                 ap->fastdrain_cnt = cnt;
     846                 :          0 :                 ap->fastdrain_timer.expires =
     847                 :          0 :                         ata_deadline(jiffies, ATA_EH_FASTDRAIN_INTERVAL);
     848                 :          0 :                 add_timer(&ap->fastdrain_timer);
     849                 :            :         }
     850                 :            : 
     851                 :          0 :  out_unlock:
     852                 :          0 :         spin_unlock_irqrestore(ap->lock, flags);
     853                 :          0 : }
     854                 :            : 
     855                 :            : /**
     856                 :            :  *      ata_eh_set_pending - set ATA_PFLAG_EH_PENDING and activate fast drain
     857                 :            :  *      @ap: target ATA port
     858                 :            :  *      @fastdrain: activate fast drain
     859                 :            :  *
     860                 :            :  *      Set ATA_PFLAG_EH_PENDING and activate fast drain if @fastdrain
     861                 :            :  *      is non-zero and EH wasn't pending before.  Fast drain ensures
     862                 :            :  *      that EH kicks in in timely manner.
     863                 :            :  *
     864                 :            :  *      LOCKING:
     865                 :            :  *      spin_lock_irqsave(host lock)
     866                 :            :  */
     867                 :         38 : static void ata_eh_set_pending(struct ata_port *ap, int fastdrain)
     868                 :            : {
     869                 :         38 :         int cnt;
     870                 :            : 
     871                 :            :         /* already scheduled? */
     872         [ +  - ]:         35 :         if (ap->pflags & ATA_PFLAG_EH_PENDING)
     873                 :            :                 return;
     874                 :            : 
     875                 :         38 :         ap->pflags |= ATA_PFLAG_EH_PENDING;
     876                 :            : 
     877         [ +  - ]:         38 :         if (!fastdrain)
     878                 :            :                 return;
     879                 :            : 
     880                 :            :         /* do we have in-flight qcs? */
     881                 :            :         cnt = ata_eh_nr_in_flight(ap);
     882         [ -  + ]:         35 :         if (!cnt)
     883                 :            :                 return;
     884                 :            : 
     885                 :            :         /* activate fast drain */
     886                 :          0 :         ap->fastdrain_cnt = cnt;
     887                 :          0 :         ap->fastdrain_timer.expires =
     888                 :          0 :                 ata_deadline(jiffies, ATA_EH_FASTDRAIN_INTERVAL);
     889                 :          0 :         add_timer(&ap->fastdrain_timer);
     890                 :            : }
     891                 :            : 
     892                 :            : /**
     893                 :            :  *      ata_qc_schedule_eh - schedule qc for error handling
     894                 :            :  *      @qc: command to schedule error handling for
     895                 :            :  *
     896                 :            :  *      Schedule error handling for @qc.  EH will kick in as soon as
     897                 :            :  *      other commands are drained.
     898                 :            :  *
     899                 :            :  *      LOCKING:
     900                 :            :  *      spin_lock_irqsave(host lock)
     901                 :            :  */
     902                 :         29 : void ata_qc_schedule_eh(struct ata_queued_cmd *qc)
     903                 :            : {
     904                 :         29 :         struct ata_port *ap = qc->ap;
     905                 :            : 
     906         [ -  + ]:         29 :         WARN_ON(!ap->ops->error_handler);
     907                 :            : 
     908                 :         29 :         qc->flags |= ATA_QCFLAG_FAILED;
     909                 :         29 :         ata_eh_set_pending(ap, 1);
     910                 :            : 
     911                 :            :         /* The following will fail if timeout has already expired.
     912                 :            :          * ata_scsi_error() takes care of such scmds on EH entry.
     913                 :            :          * Note that ATA_QCFLAG_FAILED is unconditionally set after
     914                 :            :          * this function completes.
     915                 :            :          */
     916                 :         29 :         blk_abort_request(qc->scsicmd->request);
     917                 :         29 : }
     918                 :            : 
     919                 :            : /**
     920                 :            :  * ata_std_sched_eh - non-libsas ata_ports issue eh with this common routine
     921                 :            :  * @ap: ATA port to schedule EH for
     922                 :            :  *
     923                 :            :  *      LOCKING: inherited from ata_port_schedule_eh
     924                 :            :  *      spin_lock_irqsave(host lock)
     925                 :            :  */
     926                 :          6 : void ata_std_sched_eh(struct ata_port *ap)
     927                 :            : {
     928         [ -  + ]:          6 :         WARN_ON(!ap->ops->error_handler);
     929                 :            : 
     930         [ +  - ]:          6 :         if (ap->pflags & ATA_PFLAG_INITIALIZING)
     931                 :            :                 return;
     932                 :            : 
     933                 :          6 :         ata_eh_set_pending(ap, 1);
     934                 :          6 :         scsi_schedule_eh(ap->scsi_host);
     935                 :            : 
     936                 :          6 :         DPRINTK("port EH scheduled\n");
     937                 :            : }
     938                 :            : EXPORT_SYMBOL_GPL(ata_std_sched_eh);
     939                 :            : 
     940                 :            : /**
     941                 :            :  * ata_std_end_eh - non-libsas ata_ports complete eh with this common routine
     942                 :            :  * @ap: ATA port to end EH for
     943                 :            :  *
     944                 :            :  * In the libata object model there is a 1:1 mapping of ata_port to
     945                 :            :  * shost, so host fields can be directly manipulated under ap->lock, in
     946                 :            :  * the libsas case we need to hold a lock at the ha->level to coordinate
     947                 :            :  * these events.
     948                 :            :  *
     949                 :            :  *      LOCKING:
     950                 :            :  *      spin_lock_irqsave(host lock)
     951                 :            :  */
     952                 :         35 : void ata_std_end_eh(struct ata_port *ap)
     953                 :            : {
     954                 :         35 :         struct Scsi_Host *host = ap->scsi_host;
     955                 :            : 
     956                 :         35 :         host->host_eh_scheduled = 0;
     957                 :         35 : }
     958                 :            : EXPORT_SYMBOL(ata_std_end_eh);
     959                 :            : 
     960                 :            : 
     961                 :            : /**
     962                 :            :  *      ata_port_schedule_eh - schedule error handling without a qc
     963                 :            :  *      @ap: ATA port to schedule EH for
     964                 :            :  *
     965                 :            :  *      Schedule error handling for @ap.  EH will kick in as soon as
     966                 :            :  *      all commands are drained.
     967                 :            :  *
     968                 :            :  *      LOCKING:
     969                 :            :  *      spin_lock_irqsave(host lock)
     970                 :            :  */
     971                 :          6 : void ata_port_schedule_eh(struct ata_port *ap)
     972                 :            : {
     973                 :            :         /* see: ata_std_sched_eh, unless you know better */
     974                 :          6 :         ap->ops->sched_eh(ap);
     975                 :          0 : }
     976                 :            : 
     977                 :          3 : static int ata_do_link_abort(struct ata_port *ap, struct ata_link *link)
     978                 :            : {
     979                 :          3 :         struct ata_queued_cmd *qc;
     980                 :          3 :         int tag, nr_aborted = 0;
     981                 :            : 
     982         [ -  + ]:          3 :         WARN_ON(!ap->ops->error_handler);
     983                 :            : 
     984                 :            :         /* we're gonna abort all commands, no need for fast drain */
     985         [ +  - ]:          3 :         ata_eh_set_pending(ap, 0);
     986                 :            : 
     987                 :            :         /* include internal tag in iteration */
     988   [ +  +  +  - ]:        102 :         ata_qc_for_each_with_internal(ap, qc, tag) {
     989   [ -  +  -  -  :          3 :                 if (qc && (!link || qc->dev->link == link)) {
                   +  - ]
     990                 :          3 :                         qc->flags |= ATA_QCFLAG_FAILED;
     991                 :          3 :                         ata_qc_complete(qc);
     992                 :          3 :                         nr_aborted++;
     993                 :            :                 }
     994                 :            :         }
     995                 :            : 
     996         [ -  + ]:          3 :         if (!nr_aborted)
     997                 :          0 :                 ata_port_schedule_eh(ap);
     998                 :            : 
     999                 :          3 :         return nr_aborted;
    1000                 :            : }
    1001                 :            : 
    1002                 :            : /**
    1003                 :            :  *      ata_link_abort - abort all qc's on the link
    1004                 :            :  *      @link: ATA link to abort qc's for
    1005                 :            :  *
    1006                 :            :  *      Abort all active qc's active on @link and schedule EH.
    1007                 :            :  *
    1008                 :            :  *      LOCKING:
    1009                 :            :  *      spin_lock_irqsave(host lock)
    1010                 :            :  *
    1011                 :            :  *      RETURNS:
    1012                 :            :  *      Number of aborted qc's.
    1013                 :            :  */
    1014                 :          0 : int ata_link_abort(struct ata_link *link)
    1015                 :            : {
    1016                 :          0 :         return ata_do_link_abort(link->ap, link);
    1017                 :            : }
    1018                 :            : 
    1019                 :            : /**
    1020                 :            :  *      ata_port_abort - abort all qc's on the port
    1021                 :            :  *      @ap: ATA port to abort qc's for
    1022                 :            :  *
    1023                 :            :  *      Abort all active qc's of @ap and schedule EH.
    1024                 :            :  *
    1025                 :            :  *      LOCKING:
    1026                 :            :  *      spin_lock_irqsave(host_set lock)
    1027                 :            :  *
    1028                 :            :  *      RETURNS:
    1029                 :            :  *      Number of aborted qc's.
    1030                 :            :  */
    1031                 :          3 : int ata_port_abort(struct ata_port *ap)
    1032                 :            : {
    1033                 :          0 :         return ata_do_link_abort(ap, NULL);
    1034                 :            : }
    1035                 :            : 
    1036                 :            : /**
    1037                 :            :  *      __ata_port_freeze - freeze port
    1038                 :            :  *      @ap: ATA port to freeze
    1039                 :            :  *
    1040                 :            :  *      This function is called when HSM violation or some other
    1041                 :            :  *      condition disrupts normal operation of the port.  Frozen port
    1042                 :            :  *      is not allowed to perform any operation until the port is
    1043                 :            :  *      thawed, which usually follows a successful reset.
    1044                 :            :  *
    1045                 :            :  *      ap->ops->freeze() callback can be used for freezing the port
    1046                 :            :  *      hardware-wise (e.g. mask interrupt and stop DMA engine).  If a
    1047                 :            :  *      port cannot be frozen hardware-wise, the interrupt handler
    1048                 :            :  *      must ack and clear interrupts unconditionally while the port
    1049                 :            :  *      is frozen.
    1050                 :            :  *
    1051                 :            :  *      LOCKING:
    1052                 :            :  *      spin_lock_irqsave(host lock)
    1053                 :            :  */
    1054                 :         15 : static void __ata_port_freeze(struct ata_port *ap)
    1055                 :            : {
    1056         [ -  + ]:         15 :         WARN_ON(!ap->ops->error_handler);
    1057                 :            : 
    1058         [ +  - ]:         15 :         if (ap->ops->freeze)
    1059                 :         15 :                 ap->ops->freeze(ap);
    1060                 :            : 
    1061                 :         15 :         ap->pflags |= ATA_PFLAG_FROZEN;
    1062                 :            : 
    1063                 :         15 :         DPRINTK("ata%u port frozen\n", ap->print_id);
    1064                 :         15 : }
    1065                 :            : 
    1066                 :            : /**
    1067                 :            :  *      ata_port_freeze - abort & freeze port
    1068                 :            :  *      @ap: ATA port to freeze
    1069                 :            :  *
    1070                 :            :  *      Abort and freeze @ap.  The freeze operation must be called
    1071                 :            :  *      first, because some hardware requires special operations
    1072                 :            :  *      before the taskfile registers are accessible.
    1073                 :            :  *
    1074                 :            :  *      LOCKING:
    1075                 :            :  *      spin_lock_irqsave(host lock)
    1076                 :            :  *
    1077                 :            :  *      RETURNS:
    1078                 :            :  *      Number of aborted commands.
    1079                 :            :  */
    1080                 :          3 : int ata_port_freeze(struct ata_port *ap)
    1081                 :            : {
    1082                 :          3 :         int nr_aborted;
    1083                 :            : 
    1084         [ -  + ]:          3 :         WARN_ON(!ap->ops->error_handler);
    1085                 :            : 
    1086                 :          3 :         __ata_port_freeze(ap);
    1087                 :          3 :         nr_aborted = ata_port_abort(ap);
    1088                 :            : 
    1089                 :          3 :         return nr_aborted;
    1090                 :            : }
    1091                 :            : 
    1092                 :            : /**
    1093                 :            :  *      sata_async_notification - SATA async notification handler
    1094                 :            :  *      @ap: ATA port where async notification is received
    1095                 :            :  *
    1096                 :            :  *      Handler to be called when async notification via SDB FIS is
    1097                 :            :  *      received.  This function schedules EH if necessary.
    1098                 :            :  *
    1099                 :            :  *      LOCKING:
    1100                 :            :  *      spin_lock_irqsave(host lock)
    1101                 :            :  *
    1102                 :            :  *      RETURNS:
    1103                 :            :  *      1 if EH is scheduled, 0 otherwise.
    1104                 :            :  */
    1105                 :          0 : int sata_async_notification(struct ata_port *ap)
    1106                 :            : {
    1107                 :          0 :         u32 sntf;
    1108                 :          0 :         int rc;
    1109                 :            : 
    1110         [ #  # ]:          0 :         if (!(ap->flags & ATA_FLAG_AN))
    1111                 :            :                 return 0;
    1112                 :            : 
    1113                 :          0 :         rc = sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf);
    1114         [ #  # ]:          0 :         if (rc == 0)
    1115                 :          0 :                 sata_scr_write(&ap->link, SCR_NOTIFICATION, sntf);
    1116                 :            : 
    1117   [ #  #  #  # ]:          0 :         if (!sata_pmp_attached(ap) || rc) {
    1118                 :            :                 /* PMP is not attached or SNTF is not available */
    1119         [ #  # ]:          0 :                 if (!sata_pmp_attached(ap)) {
    1120                 :            :                         /* PMP is not attached.  Check whether ATAPI
    1121                 :            :                          * AN is configured.  If so, notify media
    1122                 :            :                          * change.
    1123                 :            :                          */
    1124                 :          0 :                         struct ata_device *dev = ap->link.device;
    1125                 :            : 
    1126         [ #  # ]:          0 :                         if ((dev->class == ATA_DEV_ATAPI) &&
    1127         [ #  # ]:          0 :                             (dev->flags & ATA_DFLAG_AN))
    1128                 :          0 :                                 ata_scsi_media_change_notify(dev);
    1129                 :          0 :                         return 0;
    1130                 :            :                 } else {
    1131                 :            :                         /* PMP is attached but SNTF is not available.
    1132                 :            :                          * ATAPI async media change notification is
    1133                 :            :                          * not used.  The PMP must be reporting PHY
    1134                 :            :                          * status change, schedule EH.
    1135                 :            :                          */
    1136                 :          0 :                         ata_port_schedule_eh(ap);
    1137                 :          0 :                         return 1;
    1138                 :            :                 }
    1139                 :            :         } else {
    1140                 :            :                 /* PMP is attached and SNTF is available */
    1141                 :          0 :                 struct ata_link *link;
    1142                 :            : 
    1143                 :            :                 /* check and notify ATAPI AN */
    1144         [ #  # ]:          0 :                 ata_for_each_link(link, ap, EDGE) {
    1145         [ #  # ]:          0 :                         if (!(sntf & (1 << link->pmp)))
    1146                 :          0 :                                 continue;
    1147                 :            : 
    1148         [ #  # ]:          0 :                         if ((link->device->class == ATA_DEV_ATAPI) &&
    1149         [ #  # ]:          0 :                             (link->device->flags & ATA_DFLAG_AN))
    1150                 :          0 :                                 ata_scsi_media_change_notify(link->device);
    1151                 :            :                 }
    1152                 :            : 
    1153                 :            :                 /* If PMP is reporting that PHY status of some
    1154                 :            :                  * downstream ports has changed, schedule EH.
    1155                 :            :                  */
    1156         [ #  # ]:          0 :                 if (sntf & (1 << SATA_PMP_CTRL_PORT)) {
    1157                 :          0 :                         ata_port_schedule_eh(ap);
    1158                 :          0 :                         return 1;
    1159                 :            :                 }
    1160                 :            : 
    1161                 :            :                 return 0;
    1162                 :            :         }
    1163                 :            : }
    1164                 :            : 
    1165                 :            : /**
    1166                 :            :  *      ata_eh_freeze_port - EH helper to freeze port
    1167                 :            :  *      @ap: ATA port to freeze
    1168                 :            :  *
    1169                 :            :  *      Freeze @ap.
    1170                 :            :  *
    1171                 :            :  *      LOCKING:
    1172                 :            :  *      None.
    1173                 :            :  */
    1174                 :         12 : void ata_eh_freeze_port(struct ata_port *ap)
    1175                 :            : {
    1176                 :         12 :         unsigned long flags;
    1177                 :            : 
    1178         [ +  - ]:         12 :         if (!ap->ops->error_handler)
    1179                 :            :                 return;
    1180                 :            : 
    1181                 :         12 :         spin_lock_irqsave(ap->lock, flags);
    1182                 :         12 :         __ata_port_freeze(ap);
    1183                 :         12 :         spin_unlock_irqrestore(ap->lock, flags);
    1184                 :            : }
    1185                 :            : 
    1186                 :            : /**
    1187                 :            :  *      ata_port_thaw_port - EH helper to thaw port
    1188                 :            :  *      @ap: ATA port to thaw
    1189                 :            :  *
    1190                 :            :  *      Thaw frozen port @ap.
    1191                 :            :  *
    1192                 :            :  *      LOCKING:
    1193                 :            :  *      None.
    1194                 :            :  */
    1195                 :          9 : void ata_eh_thaw_port(struct ata_port *ap)
    1196                 :            : {
    1197                 :          9 :         unsigned long flags;
    1198                 :            : 
    1199         [ +  - ]:          9 :         if (!ap->ops->error_handler)
    1200                 :            :                 return;
    1201                 :            : 
    1202                 :          9 :         spin_lock_irqsave(ap->lock, flags);
    1203                 :            : 
    1204                 :          9 :         ap->pflags &= ~ATA_PFLAG_FROZEN;
    1205                 :            : 
    1206         [ +  - ]:          9 :         if (ap->ops->thaw)
    1207                 :          9 :                 ap->ops->thaw(ap);
    1208                 :            : 
    1209                 :          9 :         spin_unlock_irqrestore(ap->lock, flags);
    1210                 :            : 
    1211                 :          9 :         DPRINTK("ata%u port thawed\n", ap->print_id);
    1212                 :            : }
    1213                 :            : 
    1214                 :         29 : static void ata_eh_scsidone(struct scsi_cmnd *scmd)
    1215                 :            : {
    1216                 :            :         /* nada */
    1217                 :         29 : }
    1218                 :            : 
    1219                 :         29 : static void __ata_eh_qc_complete(struct ata_queued_cmd *qc)
    1220                 :            : {
    1221                 :         29 :         struct ata_port *ap = qc->ap;
    1222                 :         29 :         struct scsi_cmnd *scmd = qc->scsicmd;
    1223                 :         29 :         unsigned long flags;
    1224                 :            : 
    1225                 :         29 :         spin_lock_irqsave(ap->lock, flags);
    1226                 :         29 :         qc->scsidone = ata_eh_scsidone;
    1227                 :         29 :         __ata_qc_complete(qc);
    1228   [ +  -  -  + ]:         58 :         WARN_ON(ata_tag_valid(qc->tag));
    1229                 :         29 :         spin_unlock_irqrestore(ap->lock, flags);
    1230                 :            : 
    1231                 :         29 :         scsi_eh_finish_cmd(scmd, &ap->eh_done_q);
    1232                 :         29 : }
    1233                 :            : 
    1234                 :            : /**
    1235                 :            :  *      ata_eh_qc_complete - Complete an active ATA command from EH
    1236                 :            :  *      @qc: Command to complete
    1237                 :            :  *
    1238                 :            :  *      Indicate to the mid and upper layers that an ATA command has
    1239                 :            :  *      completed.  To be used from EH.
    1240                 :            :  */
    1241                 :         29 : void ata_eh_qc_complete(struct ata_queued_cmd *qc)
    1242                 :            : {
    1243                 :         29 :         struct scsi_cmnd *scmd = qc->scsicmd;
    1244                 :         29 :         scmd->retries = scmd->allowed;
    1245                 :          0 :         __ata_eh_qc_complete(qc);
    1246                 :         29 : }
    1247                 :            : 
    1248                 :            : /**
    1249                 :            :  *      ata_eh_qc_retry - Tell midlayer to retry an ATA command after EH
    1250                 :            :  *      @qc: Command to retry
    1251                 :            :  *
    1252                 :            :  *      Indicate to the mid and upper layers that an ATA command
    1253                 :            :  *      should be retried.  To be used from EH.
    1254                 :            :  *
    1255                 :            :  *      SCSI midlayer limits the number of retries to scmd->allowed.
    1256                 :            :  *      scmd->allowed is incremented for commands which get retried
    1257                 :            :  *      due to unrelated failures (qc->err_mask is zero).
    1258                 :            :  */
    1259                 :          0 : void ata_eh_qc_retry(struct ata_queued_cmd *qc)
    1260                 :            : {
    1261                 :          0 :         struct scsi_cmnd *scmd = qc->scsicmd;
    1262         [ #  # ]:          0 :         if (!qc->err_mask)
    1263                 :          0 :                 scmd->allowed++;
    1264                 :          0 :         __ata_eh_qc_complete(qc);
    1265                 :          0 : }
    1266                 :            : 
    1267                 :            : /**
    1268                 :            :  *      ata_dev_disable - disable ATA device
    1269                 :            :  *      @dev: ATA device to disable
    1270                 :            :  *
    1271                 :            :  *      Disable @dev.
    1272                 :            :  *
    1273                 :            :  *      Locking:
    1274                 :            :  *      EH context.
    1275                 :            :  */
    1276                 :         12 : void ata_dev_disable(struct ata_device *dev)
    1277                 :            : {
    1278   [ +  -  -  + ]:         24 :         if (!ata_dev_enabled(dev))
    1279                 :            :                 return;
    1280                 :            : 
    1281         [ #  # ]:          0 :         if (ata_msg_drv(dev->link->ap))
    1282                 :          0 :                 ata_dev_warn(dev, "disabled\n");
    1283                 :          0 :         ata_acpi_on_disable(dev);
    1284                 :          0 :         ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO0 | ATA_DNXFER_QUIET);
    1285                 :          0 :         dev->class++;
    1286                 :            : 
    1287                 :            :         /* From now till the next successful probe, ering is used to
    1288                 :            :          * track probe failures.  Clear accumulated device error info.
    1289                 :            :          */
    1290                 :          0 :         ata_ering_clear(&dev->ering);
    1291                 :            : }
    1292                 :            : 
    1293                 :            : /**
    1294                 :            :  *      ata_eh_detach_dev - detach ATA device
    1295                 :            :  *      @dev: ATA device to detach
    1296                 :            :  *
    1297                 :            :  *      Detach @dev.
    1298                 :            :  *
    1299                 :            :  *      LOCKING:
    1300                 :            :  *      None.
    1301                 :            :  */
    1302                 :         12 : void ata_eh_detach_dev(struct ata_device *dev)
    1303                 :            : {
    1304                 :         12 :         struct ata_link *link = dev->link;
    1305                 :         12 :         struct ata_port *ap = link->ap;
    1306                 :         12 :         struct ata_eh_context *ehc = &link->eh_context;
    1307                 :         12 :         unsigned long flags;
    1308                 :            : 
    1309                 :         12 :         ata_dev_disable(dev);
    1310                 :            : 
    1311                 :         12 :         spin_lock_irqsave(ap->lock, flags);
    1312                 :            : 
    1313                 :         12 :         dev->flags &= ~ATA_DFLAG_DETACH;
    1314                 :            : 
    1315         [ -  + ]:         12 :         if (ata_scsi_offline_dev(dev)) {
    1316                 :          0 :                 dev->flags |= ATA_DFLAG_DETACHED;
    1317                 :          0 :                 ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG;
    1318                 :            :         }
    1319                 :            : 
    1320                 :            :         /* clear per-dev EH info */
    1321                 :         12 :         ata_eh_clear_action(link, dev, &link->eh_info, ATA_EH_PERDEV_MASK);
    1322                 :         12 :         ata_eh_clear_action(link, dev, &link->eh_context.i, ATA_EH_PERDEV_MASK);
    1323                 :         12 :         ehc->saved_xfer_mode[dev->devno] = 0;
    1324                 :         12 :         ehc->saved_ncq_enabled &= ~(1 << dev->devno);
    1325                 :            : 
    1326                 :         12 :         spin_unlock_irqrestore(ap->lock, flags);
    1327                 :         12 : }
    1328                 :            : 
    1329                 :            : /**
    1330                 :            :  *      ata_eh_about_to_do - about to perform eh_action
    1331                 :            :  *      @link: target ATA link
    1332                 :            :  *      @dev: target ATA dev for per-dev action (can be NULL)
    1333                 :            :  *      @action: action about to be performed
    1334                 :            :  *
    1335                 :            :  *      Called just before performing EH actions to clear related bits
    1336                 :            :  *      in @link->eh_info such that eh actions are not unnecessarily
    1337                 :            :  *      repeated.
    1338                 :            :  *
    1339                 :            :  *      LOCKING:
    1340                 :            :  *      None.
    1341                 :            :  */
    1342                 :          6 : void ata_eh_about_to_do(struct ata_link *link, struct ata_device *dev,
    1343                 :            :                         unsigned int action)
    1344                 :            : {
    1345                 :          6 :         struct ata_port *ap = link->ap;
    1346                 :          6 :         struct ata_eh_info *ehi = &link->eh_info;
    1347                 :          6 :         struct ata_eh_context *ehc = &link->eh_context;
    1348                 :          6 :         unsigned long flags;
    1349                 :            : 
    1350                 :          6 :         spin_lock_irqsave(ap->lock, flags);
    1351                 :            : 
    1352                 :          6 :         ata_eh_clear_action(link, dev, ehi, action);
    1353                 :            : 
    1354                 :            :         /* About to take EH action, set RECOVERED.  Ignore actions on
    1355                 :            :          * slave links as master will do them again.
    1356                 :            :          */
    1357   [ -  +  -  - ]:          6 :         if (!(ehc->i.flags & ATA_EHI_QUIET) && link != ap->slave_link)
    1358                 :          0 :                 ap->pflags |= ATA_PFLAG_RECOVERED;
    1359                 :            : 
    1360                 :          6 :         spin_unlock_irqrestore(ap->lock, flags);
    1361                 :          6 : }
    1362                 :            : 
    1363                 :            : /**
    1364                 :            :  *      ata_eh_done - EH action complete
    1365                 :            :  *      @link: ATA link for which EH actions are complete
    1366                 :            :  *      @dev: target ATA dev for per-dev action (can be NULL)
    1367                 :            :  *      @action: action just completed
    1368                 :            :  *
    1369                 :            :  *      Called right after performing EH actions to clear related bits
    1370                 :            :  *      in @link->eh_context.
    1371                 :            :  *
    1372                 :            :  *      LOCKING:
    1373                 :            :  *      None.
    1374                 :            :  */
    1375                 :          6 : void ata_eh_done(struct ata_link *link, struct ata_device *dev,
    1376                 :            :                  unsigned int action)
    1377                 :            : {
    1378                 :          6 :         struct ata_eh_context *ehc = &link->eh_context;
    1379                 :            : 
    1380                 :          0 :         ata_eh_clear_action(link, dev, &ehc->i, action);
    1381                 :          0 : }
    1382                 :            : 
    1383                 :            : /**
    1384                 :            :  *      ata_err_string - convert err_mask to descriptive string
    1385                 :            :  *      @err_mask: error mask to convert to string
    1386                 :            :  *
    1387                 :            :  *      Convert @err_mask to descriptive string.  Errors are
    1388                 :            :  *      prioritized according to severity and only the most severe
    1389                 :            :  *      error is reported.
    1390                 :            :  *
    1391                 :            :  *      LOCKING:
    1392                 :            :  *      None.
    1393                 :            :  *
    1394                 :            :  *      RETURNS:
    1395                 :            :  *      Descriptive string for @err_mask
    1396                 :            :  */
    1397                 :          0 : static const char *ata_err_string(unsigned int err_mask)
    1398                 :            : {
    1399         [ #  # ]:          0 :         if (err_mask & AC_ERR_HOST_BUS)
    1400                 :            :                 return "host bus error";
    1401         [ #  # ]:          0 :         if (err_mask & AC_ERR_ATA_BUS)
    1402                 :            :                 return "ATA bus error";
    1403         [ #  # ]:          0 :         if (err_mask & AC_ERR_TIMEOUT)
    1404                 :            :                 return "timeout";
    1405         [ #  # ]:          0 :         if (err_mask & AC_ERR_HSM)
    1406                 :            :                 return "HSM violation";
    1407         [ #  # ]:          0 :         if (err_mask & AC_ERR_SYSTEM)
    1408                 :            :                 return "internal error";
    1409         [ #  # ]:          0 :         if (err_mask & AC_ERR_MEDIA)
    1410                 :            :                 return "media error";
    1411         [ #  # ]:          0 :         if (err_mask & AC_ERR_INVALID)
    1412                 :            :                 return "invalid argument";
    1413         [ #  # ]:          0 :         if (err_mask & AC_ERR_DEV)
    1414                 :            :                 return "device error";
    1415         [ #  # ]:          0 :         if (err_mask & AC_ERR_NCQ)
    1416                 :            :                 return "NCQ error";
    1417         [ #  # ]:          0 :         if (err_mask & AC_ERR_NODEV_HINT)
    1418                 :          0 :                 return "Polling detection error";
    1419                 :            :         return "unknown error";
    1420                 :            : }
    1421                 :            : 
    1422                 :            : /**
    1423                 :            :  *      ata_eh_read_log_10h - Read log page 10h for NCQ error details
    1424                 :            :  *      @dev: Device to read log page 10h from
    1425                 :            :  *      @tag: Resulting tag of the failed command
    1426                 :            :  *      @tf: Resulting taskfile registers of the failed command
    1427                 :            :  *
    1428                 :            :  *      Read log page 10h to obtain NCQ error details and clear error
    1429                 :            :  *      condition.
    1430                 :            :  *
    1431                 :            :  *      LOCKING:
    1432                 :            :  *      Kernel thread context (may sleep).
    1433                 :            :  *
    1434                 :            :  *      RETURNS:
    1435                 :            :  *      0 on success, -errno otherwise.
    1436                 :            :  */
    1437                 :          0 : static int ata_eh_read_log_10h(struct ata_device *dev,
    1438                 :            :                                int *tag, struct ata_taskfile *tf)
    1439                 :            : {
    1440                 :          0 :         u8 *buf = dev->link->ap->sector_buf;
    1441                 :          0 :         unsigned int err_mask;
    1442                 :          0 :         u8 csum;
    1443                 :          0 :         int i;
    1444                 :            : 
    1445                 :          0 :         err_mask = ata_read_log_page(dev, ATA_LOG_SATA_NCQ, 0, buf, 1);
    1446         [ #  # ]:          0 :         if (err_mask)
    1447                 :            :                 return -EIO;
    1448                 :            : 
    1449                 :            :         csum = 0;
    1450         [ #  # ]:          0 :         for (i = 0; i < ATA_SECT_SIZE; i++)
    1451                 :          0 :                 csum += buf[i];
    1452         [ #  # ]:          0 :         if (csum)
    1453                 :          0 :                 ata_dev_warn(dev, "invalid checksum 0x%x on log page 10h\n",
    1454                 :            :                              csum);
    1455                 :            : 
    1456         [ #  # ]:          0 :         if (buf[0] & 0x80)
    1457                 :            :                 return -ENOENT;
    1458                 :            : 
    1459                 :          0 :         *tag = buf[0] & 0x1f;
    1460                 :            : 
    1461                 :          0 :         tf->command = buf[2];
    1462                 :          0 :         tf->feature = buf[3];
    1463                 :          0 :         tf->lbal = buf[4];
    1464                 :          0 :         tf->lbam = buf[5];
    1465                 :          0 :         tf->lbah = buf[6];
    1466                 :          0 :         tf->device = buf[7];
    1467                 :          0 :         tf->hob_lbal = buf[8];
    1468                 :          0 :         tf->hob_lbam = buf[9];
    1469                 :          0 :         tf->hob_lbah = buf[10];
    1470                 :          0 :         tf->nsect = buf[12];
    1471                 :          0 :         tf->hob_nsect = buf[13];
    1472   [ #  #  #  # ]:          0 :         if (dev->class == ATA_DEV_ZAC && ata_id_has_ncq_autosense(dev->id))
    1473                 :          0 :                 tf->auxiliary = buf[14] << 16 | buf[15] << 8 | buf[16];
    1474                 :            : 
    1475                 :            :         return 0;
    1476                 :            : }
    1477                 :            : 
    1478                 :            : /**
    1479                 :            :  *      atapi_eh_tur - perform ATAPI TEST_UNIT_READY
    1480                 :            :  *      @dev: target ATAPI device
    1481                 :            :  *      @r_sense_key: out parameter for sense_key
    1482                 :            :  *
    1483                 :            :  *      Perform ATAPI TEST_UNIT_READY.
    1484                 :            :  *
    1485                 :            :  *      LOCKING:
    1486                 :            :  *      EH context (may sleep).
    1487                 :            :  *
    1488                 :            :  *      RETURNS:
    1489                 :            :  *      0 on success, AC_ERR_* mask on failure.
    1490                 :            :  */
    1491                 :          3 : unsigned int atapi_eh_tur(struct ata_device *dev, u8 *r_sense_key)
    1492                 :            : {
    1493                 :          3 :         u8 cdb[ATAPI_CDB_LEN] = { TEST_UNIT_READY, 0, 0, 0, 0, 0 };
    1494                 :          3 :         struct ata_taskfile tf;
    1495                 :          3 :         unsigned int err_mask;
    1496                 :            : 
    1497         [ +  - ]:          3 :         ata_tf_init(dev, &tf);
    1498                 :            : 
    1499                 :          3 :         tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
    1500                 :          3 :         tf.command = ATA_CMD_PACKET;
    1501                 :          3 :         tf.protocol = ATAPI_PROT_NODATA;
    1502                 :            : 
    1503                 :          3 :         err_mask = ata_exec_internal(dev, &tf, cdb, DMA_NONE, NULL, 0, 0);
    1504         [ +  - ]:          3 :         if (err_mask == AC_ERR_DEV)
    1505                 :          3 :                 *r_sense_key = tf.feature >> 4;
    1506                 :          3 :         return err_mask;
    1507                 :            : }
    1508                 :            : 
    1509                 :            : /**
    1510                 :            :  *      ata_eh_request_sense - perform REQUEST_SENSE_DATA_EXT
    1511                 :            :  *      @qc: qc to perform REQUEST_SENSE_SENSE_DATA_EXT to
    1512                 :            :  *      @cmd: scsi command for which the sense code should be set
    1513                 :            :  *
    1514                 :            :  *      Perform REQUEST_SENSE_DATA_EXT after the device reported CHECK
    1515                 :            :  *      SENSE.  This function is an EH helper.
    1516                 :            :  *
    1517                 :            :  *      LOCKING:
    1518                 :            :  *      Kernel thread context (may sleep).
    1519                 :            :  */
    1520                 :          0 : static void ata_eh_request_sense(struct ata_queued_cmd *qc,
    1521                 :            :                                  struct scsi_cmnd *cmd)
    1522                 :            : {
    1523                 :          0 :         struct ata_device *dev = qc->dev;
    1524                 :          0 :         struct ata_taskfile tf;
    1525                 :          0 :         unsigned int err_mask;
    1526                 :            : 
    1527         [ #  # ]:          0 :         if (qc->ap->pflags & ATA_PFLAG_FROZEN) {
    1528                 :          0 :                 ata_dev_warn(dev, "sense data available but port frozen\n");
    1529                 :          0 :                 return;
    1530                 :            :         }
    1531                 :            : 
    1532   [ #  #  #  # ]:          0 :         if (!cmd || qc->flags & ATA_QCFLAG_SENSE_VALID)
    1533                 :            :                 return;
    1534                 :            : 
    1535   [ #  #  #  # ]:          0 :         if (!ata_id_sense_reporting_enabled(dev->id)) {
    1536                 :          0 :                 ata_dev_warn(qc->dev, "sense data reporting disabled\n");
    1537                 :          0 :                 return;
    1538                 :            :         }
    1539                 :            : 
    1540                 :          0 :         DPRINTK("ATA request sense\n");
    1541                 :            : 
    1542         [ #  # ]:          0 :         ata_tf_init(dev, &tf);
    1543                 :          0 :         tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
    1544                 :          0 :         tf.flags |= ATA_TFLAG_LBA | ATA_TFLAG_LBA48;
    1545                 :          0 :         tf.command = ATA_CMD_REQ_SENSE_DATA;
    1546                 :          0 :         tf.protocol = ATA_PROT_NODATA;
    1547                 :            : 
    1548                 :          0 :         err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
    1549                 :            :         /* Ignore err_mask; ATA_ERR might be set */
    1550         [ #  # ]:          0 :         if (tf.command & ATA_SENSE) {
    1551                 :          0 :                 ata_scsi_set_sense(dev, cmd, tf.lbah, tf.lbam, tf.lbal);
    1552                 :          0 :                 qc->flags |= ATA_QCFLAG_SENSE_VALID;
    1553                 :            :         } else {
    1554                 :          0 :                 ata_dev_warn(dev, "request sense failed stat %02x emask %x\n",
    1555                 :            :                              tf.command, err_mask);
    1556                 :            :         }
    1557                 :            : }
    1558                 :            : 
    1559                 :            : /**
    1560                 :            :  *      atapi_eh_request_sense - perform ATAPI REQUEST_SENSE
    1561                 :            :  *      @dev: device to perform REQUEST_SENSE to
    1562                 :            :  *      @sense_buf: result sense data buffer (SCSI_SENSE_BUFFERSIZE bytes long)
    1563                 :            :  *      @dfl_sense_key: default sense key to use
    1564                 :            :  *
    1565                 :            :  *      Perform ATAPI REQUEST_SENSE after the device reported CHECK
    1566                 :            :  *      SENSE.  This function is EH helper.
    1567                 :            :  *
    1568                 :            :  *      LOCKING:
    1569                 :            :  *      Kernel thread context (may sleep).
    1570                 :            :  *
    1571                 :            :  *      RETURNS:
    1572                 :            :  *      0 on success, AC_ERR_* mask on failure
    1573                 :            :  */
    1574                 :         29 : unsigned int atapi_eh_request_sense(struct ata_device *dev,
    1575                 :            :                                            u8 *sense_buf, u8 dfl_sense_key)
    1576                 :            : {
    1577                 :         29 :         u8 cdb[ATAPI_CDB_LEN] =
    1578                 :            :                 { REQUEST_SENSE, 0, 0, 0, SCSI_SENSE_BUFFERSIZE, 0 };
    1579                 :         29 :         struct ata_port *ap = dev->link->ap;
    1580                 :         29 :         struct ata_taskfile tf;
    1581                 :            : 
    1582                 :         29 :         DPRINTK("ATAPI request sense\n");
    1583                 :            : 
    1584                 :         29 :         memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE);
    1585                 :            : 
    1586                 :            :         /* initialize sense_buf with the error register,
    1587                 :            :          * for the case where they are -not- overwritten
    1588                 :            :          */
    1589                 :         29 :         sense_buf[0] = 0x70;
    1590                 :         29 :         sense_buf[2] = dfl_sense_key;
    1591                 :            : 
    1592                 :            :         /* some devices time out if garbage left in tf */
    1593         [ +  - ]:         29 :         ata_tf_init(dev, &tf);
    1594                 :            : 
    1595                 :         29 :         tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
    1596                 :         29 :         tf.command = ATA_CMD_PACKET;
    1597                 :            : 
    1598                 :            :         /* is it pointless to prefer PIO for "safety reasons"? */
    1599         [ -  + ]:         29 :         if (ap->flags & ATA_FLAG_PIO_DMA) {
    1600                 :          0 :                 tf.protocol = ATAPI_PROT_DMA;
    1601                 :          0 :                 tf.feature |= ATAPI_PKT_DMA;
    1602                 :            :         } else {
    1603                 :         29 :                 tf.protocol = ATAPI_PROT_PIO;
    1604                 :         29 :                 tf.lbam = SCSI_SENSE_BUFFERSIZE;
    1605                 :         29 :                 tf.lbah = 0;
    1606                 :            :         }
    1607                 :            : 
    1608                 :         29 :         return ata_exec_internal(dev, &tf, cdb, DMA_FROM_DEVICE,
    1609                 :            :                                  sense_buf, SCSI_SENSE_BUFFERSIZE, 0);
    1610                 :            : }
    1611                 :            : 
    1612                 :            : /**
    1613                 :            :  *      ata_eh_analyze_serror - analyze SError for a failed port
    1614                 :            :  *      @link: ATA link to analyze SError for
    1615                 :            :  *
    1616                 :            :  *      Analyze SError if available and further determine cause of
    1617                 :            :  *      failure.
    1618                 :            :  *
    1619                 :            :  *      LOCKING:
    1620                 :            :  *      None.
    1621                 :            :  */
    1622                 :          0 : static void ata_eh_analyze_serror(struct ata_link *link)
    1623                 :            : {
    1624                 :          0 :         struct ata_eh_context *ehc = &link->eh_context;
    1625                 :          0 :         u32 serror = ehc->i.serror;
    1626                 :          0 :         unsigned int err_mask = 0, action = 0;
    1627                 :          0 :         u32 hotplug_mask;
    1628                 :            : 
    1629         [ #  # ]:          0 :         if (serror & (SERR_PERSISTENT | SERR_DATA)) {
    1630                 :          0 :                 err_mask |= AC_ERR_ATA_BUS;
    1631                 :          0 :                 action |= ATA_EH_RESET;
    1632                 :            :         }
    1633         [ #  # ]:          0 :         if (serror & SERR_PROTOCOL) {
    1634                 :          0 :                 err_mask |= AC_ERR_HSM;
    1635                 :          0 :                 action |= ATA_EH_RESET;
    1636                 :            :         }
    1637         [ #  # ]:          0 :         if (serror & SERR_INTERNAL) {
    1638                 :          0 :                 err_mask |= AC_ERR_SYSTEM;
    1639                 :          0 :                 action |= ATA_EH_RESET;
    1640                 :            :         }
    1641                 :            : 
    1642                 :            :         /* Determine whether a hotplug event has occurred.  Both
    1643                 :            :          * SError.N/X are considered hotplug events for enabled or
    1644                 :            :          * host links.  For disabled PMP links, only N bit is
    1645                 :            :          * considered as X bit is left at 1 for link plugging.
    1646                 :            :          */
    1647         [ #  # ]:          0 :         if (link->lpm_policy > ATA_LPM_MAX_POWER)
    1648                 :            :                 hotplug_mask = 0;       /* hotplug doesn't work w/ LPM */
    1649   [ #  #  #  # ]:          0 :         else if (!(link->flags & ATA_LFLAG_DISABLED) || ata_is_host_link(link))
    1650                 :            :                 hotplug_mask = SERR_PHYRDY_CHG | SERR_DEV_XCHG;
    1651                 :            :         else
    1652                 :            :                 hotplug_mask = SERR_PHYRDY_CHG;
    1653                 :            : 
    1654         [ #  # ]:          0 :         if (serror & hotplug_mask)
    1655                 :          0 :                 ata_ehi_hotplugged(&ehc->i);
    1656                 :            : 
    1657                 :          0 :         ehc->i.err_mask |= err_mask;
    1658                 :          0 :         ehc->i.action |= action;
    1659                 :          0 : }
    1660                 :            : 
    1661                 :            : /**
    1662                 :            :  *      ata_eh_analyze_ncq_error - analyze NCQ error
    1663                 :            :  *      @link: ATA link to analyze NCQ error for
    1664                 :            :  *
    1665                 :            :  *      Read log page 10h, determine the offending qc and acquire
    1666                 :            :  *      error status TF.  For NCQ device errors, all LLDDs have to do
    1667                 :            :  *      is setting AC_ERR_DEV in ehi->err_mask.  This function takes
    1668                 :            :  *      care of the rest.
    1669                 :            :  *
    1670                 :            :  *      LOCKING:
    1671                 :            :  *      Kernel thread context (may sleep).
    1672                 :            :  */
    1673                 :         32 : void ata_eh_analyze_ncq_error(struct ata_link *link)
    1674                 :            : {
    1675                 :         32 :         struct ata_port *ap = link->ap;
    1676                 :         32 :         struct ata_eh_context *ehc = &link->eh_context;
    1677                 :         32 :         struct ata_device *dev = link->device;
    1678                 :         32 :         struct ata_queued_cmd *qc;
    1679                 :         32 :         struct ata_taskfile tf;
    1680                 :         32 :         int tag, rc;
    1681                 :            : 
    1682                 :            :         /* if frozen, we can't do much */
    1683         [ +  - ]:         32 :         if (ap->pflags & ATA_PFLAG_FROZEN)
    1684                 :         32 :                 return;
    1685                 :            : 
    1686                 :            :         /* is it NCQ device error? */
    1687   [ -  +  -  - ]:         32 :         if (!link->sactive || !(ehc->i.err_mask & AC_ERR_DEV))
    1688                 :            :                 return;
    1689                 :            : 
    1690                 :            :         /* has LLDD analyzed already? */
    1691   [ #  #  #  # ]:          0 :         ata_qc_for_each_raw(ap, qc, tag) {
    1692         [ #  # ]:          0 :                 if (!(qc->flags & ATA_QCFLAG_FAILED))
    1693                 :          0 :                         continue;
    1694                 :            : 
    1695         [ #  # ]:          0 :                 if (qc->err_mask)
    1696                 :            :                         return;
    1697                 :            :         }
    1698                 :            : 
    1699                 :            :         /* okay, this error is ours */
    1700                 :          0 :         memset(&tf, 0, sizeof(tf));
    1701                 :          0 :         rc = ata_eh_read_log_10h(dev, &tag, &tf);
    1702         [ #  # ]:          0 :         if (rc) {
    1703                 :          0 :                 ata_link_err(link, "failed to read log page 10h (errno=%d)\n",
    1704                 :            :                              rc);
    1705                 :          0 :                 return;
    1706                 :            :         }
    1707                 :            : 
    1708         [ #  # ]:          0 :         if (!(link->sactive & (1 << tag))) {
    1709                 :          0 :                 ata_link_err(link, "log page 10h reported inactive tag %d\n",
    1710                 :            :                              tag);
    1711                 :          0 :                 return;
    1712                 :            :         }
    1713                 :            : 
    1714                 :            :         /* we've got the perpetrator, condemn it */
    1715         [ #  # ]:          0 :         qc = __ata_qc_from_tag(ap, tag);
    1716                 :          0 :         memcpy(&qc->result_tf, &tf, sizeof(tf));
    1717                 :          0 :         qc->result_tf.flags = ATA_TFLAG_ISADDR | ATA_TFLAG_LBA | ATA_TFLAG_LBA48;
    1718                 :          0 :         qc->err_mask |= AC_ERR_DEV | AC_ERR_NCQ;
    1719         [ #  # ]:          0 :         if (dev->class == ATA_DEV_ZAC &&
    1720   [ #  #  #  # ]:          0 :             ((qc->result_tf.command & ATA_SENSE) || qc->result_tf.auxiliary)) {
    1721                 :          0 :                 char sense_key, asc, ascq;
    1722                 :            : 
    1723                 :          0 :                 sense_key = (qc->result_tf.auxiliary >> 16) & 0xff;
    1724                 :          0 :                 asc = (qc->result_tf.auxiliary >> 8) & 0xff;
    1725                 :          0 :                 ascq = qc->result_tf.auxiliary & 0xff;
    1726                 :          0 :                 ata_scsi_set_sense(dev, qc->scsicmd, sense_key, asc, ascq);
    1727                 :          0 :                 ata_scsi_set_sense_information(dev, qc->scsicmd,
    1728                 :            :                                                &qc->result_tf);
    1729                 :          0 :                 qc->flags |= ATA_QCFLAG_SENSE_VALID;
    1730                 :            :         }
    1731                 :            : 
    1732                 :          0 :         ehc->i.err_mask &= ~AC_ERR_DEV;
    1733                 :            : }
    1734                 :            : 
    1735                 :            : /**
    1736                 :            :  *      ata_eh_analyze_tf - analyze taskfile of a failed qc
    1737                 :            :  *      @qc: qc to analyze
    1738                 :            :  *      @tf: Taskfile registers to analyze
    1739                 :            :  *
    1740                 :            :  *      Analyze taskfile of @qc and further determine cause of
    1741                 :            :  *      failure.  This function also requests ATAPI sense data if
    1742                 :            :  *      available.
    1743                 :            :  *
    1744                 :            :  *      LOCKING:
    1745                 :            :  *      Kernel thread context (may sleep).
    1746                 :            :  *
    1747                 :            :  *      RETURNS:
    1748                 :            :  *      Determined recovery action
    1749                 :            :  */
    1750                 :            : static unsigned int ata_eh_analyze_tf(struct ata_queued_cmd *qc,
    1751                 :            :                                       const struct ata_taskfile *tf)
    1752                 :            : {
    1753                 :            :         unsigned int tmp, action = 0;
    1754                 :            :         u8 stat = tf->command, err = tf->feature;
    1755                 :            : 
    1756                 :            :         if ((stat & (ATA_BUSY | ATA_DRQ | ATA_DRDY)) != ATA_DRDY) {
    1757                 :            :                 qc->err_mask |= AC_ERR_HSM;
    1758                 :            :                 return ATA_EH_RESET;
    1759                 :            :         }
    1760                 :            : 
    1761                 :            :         if (stat & (ATA_ERR | ATA_DF)) {
    1762                 :            :                 qc->err_mask |= AC_ERR_DEV;
    1763                 :            :                 /*
    1764                 :            :                  * Sense data reporting does not work if the
    1765                 :            :                  * device fault bit is set.
    1766                 :            :                  */
    1767                 :            :                 if (stat & ATA_DF)
    1768                 :            :                         stat &= ~ATA_SENSE;
    1769                 :            :         } else {
    1770                 :            :                 return 0;
    1771                 :            :         }
    1772                 :            : 
    1773                 :            :         switch (qc->dev->class) {
    1774                 :            :         case ATA_DEV_ZAC:
    1775                 :            :                 if (stat & ATA_SENSE)
    1776                 :            :                         ata_eh_request_sense(qc, qc->scsicmd);
    1777                 :            :                 /* fall through */
    1778                 :            :         case ATA_DEV_ATA:
    1779                 :            :                 if (err & ATA_ICRC)
    1780                 :            :                         qc->err_mask |= AC_ERR_ATA_BUS;
    1781                 :            :                 if (err & (ATA_UNC | ATA_AMNF))
    1782                 :            :                         qc->err_mask |= AC_ERR_MEDIA;
    1783                 :            :                 if (err & ATA_IDNF)
    1784                 :            :                         qc->err_mask |= AC_ERR_INVALID;
    1785                 :            :                 break;
    1786                 :            : 
    1787                 :            :         case ATA_DEV_ATAPI:
    1788                 :            :                 if (!(qc->ap->pflags & ATA_PFLAG_FROZEN)) {
    1789                 :            :                         tmp = atapi_eh_request_sense(qc->dev,
    1790                 :            :                                                 qc->scsicmd->sense_buffer,
    1791                 :            :                                                 qc->result_tf.feature >> 4);
    1792                 :            :                         if (!tmp)
    1793                 :            :                                 qc->flags |= ATA_QCFLAG_SENSE_VALID;
    1794                 :            :                         else
    1795                 :            :                                 qc->err_mask |= tmp;
    1796                 :            :                 }
    1797                 :            :         }
    1798                 :            : 
    1799                 :            :         if (qc->flags & ATA_QCFLAG_SENSE_VALID) {
    1800                 :            :                 int ret = scsi_check_sense(qc->scsicmd);
    1801                 :            :                 /*
    1802                 :            :                  * SUCCESS here means that the sense code could be
    1803                 :            :                  * evaluated and should be passed to the upper layers
    1804                 :            :                  * for correct evaluation.
    1805                 :            :                  * FAILED means the sense code could not be interpreted
    1806                 :            :                  * and the device would need to be reset.
    1807                 :            :                  * NEEDS_RETRY and ADD_TO_MLQUEUE means that the
    1808                 :            :                  * command would need to be retried.
    1809                 :            :                  */
    1810                 :            :                 if (ret == NEEDS_RETRY || ret == ADD_TO_MLQUEUE) {
    1811                 :            :                         qc->flags |= ATA_QCFLAG_RETRY;
    1812                 :            :                         qc->err_mask |= AC_ERR_OTHER;
    1813                 :            :                 } else if (ret != SUCCESS) {
    1814                 :            :                         qc->err_mask |= AC_ERR_HSM;
    1815                 :            :                 }
    1816                 :            :         }
    1817                 :            :         if (qc->err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT | AC_ERR_ATA_BUS))
    1818                 :            :                 action |= ATA_EH_RESET;
    1819                 :            : 
    1820                 :            :         return action;
    1821                 :            : }
    1822                 :            : 
    1823                 :         29 : static int ata_eh_categorize_error(unsigned int eflags, unsigned int err_mask,
    1824                 :            :                                    int *xfer_ok)
    1825                 :            : {
    1826                 :         29 :         int base = 0;
    1827                 :            : 
    1828         [ +  - ]:         29 :         if (!(eflags & ATA_EFLAG_DUBIOUS_XFER))
    1829                 :         29 :                 *xfer_ok = 1;
    1830                 :            : 
    1831         [ -  + ]:         29 :         if (!*xfer_ok)
    1832                 :          0 :                 base = ATA_ECAT_DUBIOUS_NONE;
    1833                 :            : 
    1834         [ -  + ]:         29 :         if (err_mask & AC_ERR_ATA_BUS)
    1835                 :          0 :                 return base + ATA_ECAT_ATA_BUS;
    1836                 :            : 
    1837         [ -  + ]:         29 :         if (err_mask & AC_ERR_TIMEOUT)
    1838                 :          0 :                 return base + ATA_ECAT_TOUT_HSM;
    1839                 :            : 
    1840         [ -  + ]:         29 :         if (eflags & ATA_EFLAG_IS_IO) {
    1841         [ #  # ]:          0 :                 if (err_mask & AC_ERR_HSM)
    1842                 :          0 :                         return base + ATA_ECAT_TOUT_HSM;
    1843         [ #  # ]:          0 :                 if ((err_mask &
    1844                 :            :                      (AC_ERR_DEV|AC_ERR_MEDIA|AC_ERR_INVALID)) == AC_ERR_DEV)
    1845                 :          0 :                         return base + ATA_ECAT_UNK_DEV;
    1846                 :            :         }
    1847                 :            : 
    1848                 :            :         return 0;
    1849                 :            : }
    1850                 :            : 
    1851                 :            : struct speed_down_verdict_arg {
    1852                 :            :         u64 since;
    1853                 :            :         int xfer_ok;
    1854                 :            :         int nr_errors[ATA_ECAT_NR];
    1855                 :            : };
    1856                 :            : 
    1857                 :          0 : static int speed_down_verdict_cb(struct ata_ering_entry *ent, void *void_arg)
    1858                 :            : {
    1859                 :          0 :         struct speed_down_verdict_arg *arg = void_arg;
    1860                 :          0 :         int cat;
    1861                 :            : 
    1862   [ #  #  #  # ]:          0 :         if ((ent->eflags & ATA_EFLAG_OLD_ER) || (ent->timestamp < arg->since))
    1863                 :            :                 return -1;
    1864                 :            : 
    1865                 :          0 :         cat = ata_eh_categorize_error(ent->eflags, ent->err_mask,
    1866                 :            :                                       &arg->xfer_ok);
    1867                 :          0 :         arg->nr_errors[cat]++;
    1868                 :            : 
    1869                 :          0 :         return 0;
    1870                 :            : }
    1871                 :            : 
    1872                 :            : /**
    1873                 :            :  *      ata_eh_speed_down_verdict - Determine speed down verdict
    1874                 :            :  *      @dev: Device of interest
    1875                 :            :  *
    1876                 :            :  *      This function examines error ring of @dev and determines
    1877                 :            :  *      whether NCQ needs to be turned off, transfer speed should be
    1878                 :            :  *      stepped down, or falling back to PIO is necessary.
    1879                 :            :  *
    1880                 :            :  *      ECAT_ATA_BUS    : ATA_BUS error for any command
    1881                 :            :  *
    1882                 :            :  *      ECAT_TOUT_HSM   : TIMEOUT for any command or HSM violation for
    1883                 :            :  *                        IO commands
    1884                 :            :  *
    1885                 :            :  *      ECAT_UNK_DEV    : Unknown DEV error for IO commands
    1886                 :            :  *
    1887                 :            :  *      ECAT_DUBIOUS_*  : Identical to above three but occurred while
    1888                 :            :  *                        data transfer hasn't been verified.
    1889                 :            :  *
    1890                 :            :  *      Verdicts are
    1891                 :            :  *
    1892                 :            :  *      NCQ_OFF         : Turn off NCQ.
    1893                 :            :  *
    1894                 :            :  *      SPEED_DOWN      : Speed down transfer speed but don't fall back
    1895                 :            :  *                        to PIO.
    1896                 :            :  *
    1897                 :            :  *      FALLBACK_TO_PIO : Fall back to PIO.
    1898                 :            :  *
    1899                 :            :  *      Even if multiple verdicts are returned, only one action is
    1900                 :            :  *      taken per error.  An action triggered by non-DUBIOUS errors
    1901                 :            :  *      clears ering, while one triggered by DUBIOUS_* errors doesn't.
    1902                 :            :  *      This is to expedite speed down decisions right after device is
    1903                 :            :  *      initially configured.
    1904                 :            :  *
    1905                 :            :  *      The following are speed down rules.  #1 and #2 deal with
    1906                 :            :  *      DUBIOUS errors.
    1907                 :            :  *
    1908                 :            :  *      1. If more than one DUBIOUS_ATA_BUS or DUBIOUS_TOUT_HSM errors
    1909                 :            :  *         occurred during last 5 mins, SPEED_DOWN and FALLBACK_TO_PIO.
    1910                 :            :  *
    1911                 :            :  *      2. If more than one DUBIOUS_TOUT_HSM or DUBIOUS_UNK_DEV errors
    1912                 :            :  *         occurred during last 5 mins, NCQ_OFF.
    1913                 :            :  *
    1914                 :            :  *      3. If more than 8 ATA_BUS, TOUT_HSM or UNK_DEV errors
    1915                 :            :  *         occurred during last 5 mins, FALLBACK_TO_PIO
    1916                 :            :  *
    1917                 :            :  *      4. If more than 3 TOUT_HSM or UNK_DEV errors occurred
    1918                 :            :  *         during last 10 mins, NCQ_OFF.
    1919                 :            :  *
    1920                 :            :  *      5. If more than 3 ATA_BUS or TOUT_HSM errors, or more than 6
    1921                 :            :  *         UNK_DEV errors occurred during last 10 mins, SPEED_DOWN.
    1922                 :            :  *
    1923                 :            :  *      LOCKING:
    1924                 :            :  *      Inherited from caller.
    1925                 :            :  *
    1926                 :            :  *      RETURNS:
    1927                 :            :  *      OR of ATA_EH_SPDN_* flags.
    1928                 :            :  */
    1929                 :          0 : static unsigned int ata_eh_speed_down_verdict(struct ata_device *dev)
    1930                 :            : {
    1931                 :          0 :         const u64 j5mins = 5LLU * 60 * HZ, j10mins = 10LLU * 60 * HZ;
    1932                 :          0 :         u64 j64 = get_jiffies_64();
    1933                 :          0 :         struct speed_down_verdict_arg arg;
    1934                 :          0 :         unsigned int verdict = 0;
    1935                 :            : 
    1936                 :            :         /* scan past 5 mins of error history */
    1937                 :          0 :         memset(&arg, 0, sizeof(arg));
    1938                 :          0 :         arg.since = j64 - min(j64, j5mins);
    1939                 :          0 :         ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg);
    1940                 :            : 
    1941                 :          0 :         if (arg.nr_errors[ATA_ECAT_DUBIOUS_ATA_BUS] +
    1942         [ #  # ]:          0 :             arg.nr_errors[ATA_ECAT_DUBIOUS_TOUT_HSM] > 1)
    1943                 :          0 :                 verdict |= ATA_EH_SPDN_SPEED_DOWN |
    1944                 :            :                         ATA_EH_SPDN_FALLBACK_TO_PIO | ATA_EH_SPDN_KEEP_ERRORS;
    1945                 :            : 
    1946                 :          0 :         if (arg.nr_errors[ATA_ECAT_DUBIOUS_TOUT_HSM] +
    1947         [ #  # ]:          0 :             arg.nr_errors[ATA_ECAT_DUBIOUS_UNK_DEV] > 1)
    1948                 :          0 :                 verdict |= ATA_EH_SPDN_NCQ_OFF | ATA_EH_SPDN_KEEP_ERRORS;
    1949                 :            : 
    1950                 :          0 :         if (arg.nr_errors[ATA_ECAT_ATA_BUS] +
    1951                 :          0 :             arg.nr_errors[ATA_ECAT_TOUT_HSM] +
    1952         [ #  # ]:          0 :             arg.nr_errors[ATA_ECAT_UNK_DEV] > 6)
    1953                 :          0 :                 verdict |= ATA_EH_SPDN_FALLBACK_TO_PIO;
    1954                 :            : 
    1955                 :            :         /* scan past 10 mins of error history */
    1956                 :          0 :         memset(&arg, 0, sizeof(arg));
    1957                 :          0 :         arg.since = j64 - min(j64, j10mins);
    1958                 :          0 :         ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg);
    1959                 :            : 
    1960                 :          0 :         if (arg.nr_errors[ATA_ECAT_TOUT_HSM] +
    1961         [ #  # ]:          0 :             arg.nr_errors[ATA_ECAT_UNK_DEV] > 3)
    1962                 :          0 :                 verdict |= ATA_EH_SPDN_NCQ_OFF;
    1963                 :            : 
    1964         [ #  # ]:          0 :         if (arg.nr_errors[ATA_ECAT_ATA_BUS] +
    1965         [ #  # ]:          0 :             arg.nr_errors[ATA_ECAT_TOUT_HSM] > 3 ||
    1966                 :            :             arg.nr_errors[ATA_ECAT_UNK_DEV] > 6)
    1967                 :          0 :                 verdict |= ATA_EH_SPDN_SPEED_DOWN;
    1968                 :            : 
    1969                 :          0 :         return verdict;
    1970                 :            : }
    1971                 :            : 
    1972                 :            : /**
    1973                 :            :  *      ata_eh_speed_down - record error and speed down if necessary
    1974                 :            :  *      @dev: Failed device
    1975                 :            :  *      @eflags: mask of ATA_EFLAG_* flags
    1976                 :            :  *      @err_mask: err_mask of the error
    1977                 :            :  *
    1978                 :            :  *      Record error and examine error history to determine whether
    1979                 :            :  *      adjusting transmission speed is necessary.  It also sets
    1980                 :            :  *      transmission limits appropriately if such adjustment is
    1981                 :            :  *      necessary.
    1982                 :            :  *
    1983                 :            :  *      LOCKING:
    1984                 :            :  *      Kernel thread context (may sleep).
    1985                 :            :  *
    1986                 :            :  *      RETURNS:
    1987                 :            :  *      Determined recovery action.
    1988                 :            :  */
    1989                 :         29 : static unsigned int ata_eh_speed_down(struct ata_device *dev,
    1990                 :            :                                 unsigned int eflags, unsigned int err_mask)
    1991                 :            : {
    1992                 :         29 :         struct ata_link *link = ata_dev_phys_link(dev);
    1993                 :         29 :         int xfer_ok = 0;
    1994                 :         29 :         unsigned int verdict;
    1995                 :         29 :         unsigned int action = 0;
    1996                 :            : 
    1997                 :            :         /* don't bother if Cat-0 error */
    1998         [ -  + ]:         29 :         if (ata_eh_categorize_error(eflags, err_mask, &xfer_ok) == 0)
    1999                 :            :                 return 0;
    2000                 :            : 
    2001                 :            :         /* record error and determine whether speed down is necessary */
    2002         [ #  # ]:          0 :         ata_ering_record(&dev->ering, eflags, err_mask);
    2003                 :          0 :         verdict = ata_eh_speed_down_verdict(dev);
    2004                 :            : 
    2005                 :            :         /* turn off NCQ? */
    2006         [ #  # ]:          0 :         if ((verdict & ATA_EH_SPDN_NCQ_OFF) &&
    2007         [ #  # ]:          0 :             (dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ |
    2008                 :            :                            ATA_DFLAG_NCQ_OFF)) == ATA_DFLAG_NCQ) {
    2009                 :          0 :                 dev->flags |= ATA_DFLAG_NCQ_OFF;
    2010                 :          0 :                 ata_dev_warn(dev, "NCQ disabled due to excessive errors\n");
    2011                 :          0 :                 goto done;
    2012                 :            :         }
    2013                 :            : 
    2014                 :            :         /* speed down? */
    2015         [ #  # ]:          0 :         if (verdict & ATA_EH_SPDN_SPEED_DOWN) {
    2016                 :            :                 /* speed down SATA link speed if possible */
    2017         [ #  # ]:          0 :                 if (sata_down_spd_limit(link, 0) == 0) {
    2018                 :          0 :                         action |= ATA_EH_RESET;
    2019                 :          0 :                         goto done;
    2020                 :            :                 }
    2021                 :            : 
    2022                 :            :                 /* lower transfer mode */
    2023         [ #  # ]:          0 :                 if (dev->spdn_cnt < 2) {
    2024                 :          0 :                         static const int dma_dnxfer_sel[] =
    2025                 :            :                                 { ATA_DNXFER_DMA, ATA_DNXFER_40C };
    2026                 :          0 :                         static const int pio_dnxfer_sel[] =
    2027                 :            :                                 { ATA_DNXFER_PIO, ATA_DNXFER_FORCE_PIO0 };
    2028                 :          0 :                         int sel;
    2029                 :            : 
    2030         [ #  # ]:          0 :                         if (dev->xfer_shift != ATA_SHIFT_PIO)
    2031                 :          0 :                                 sel = dma_dnxfer_sel[dev->spdn_cnt];
    2032                 :            :                         else
    2033                 :          0 :                                 sel = pio_dnxfer_sel[dev->spdn_cnt];
    2034                 :            : 
    2035                 :          0 :                         dev->spdn_cnt++;
    2036                 :            : 
    2037         [ #  # ]:          0 :                         if (ata_down_xfermask_limit(dev, sel) == 0) {
    2038                 :          0 :                                 action |= ATA_EH_RESET;
    2039                 :          0 :                                 goto done;
    2040                 :            :                         }
    2041                 :            :                 }
    2042                 :            :         }
    2043                 :            : 
    2044                 :            :         /* Fall back to PIO?  Slowing down to PIO is meaningless for
    2045                 :            :          * SATA ATA devices.  Consider it only for PATA and SATAPI.
    2046                 :            :          */
    2047   [ #  #  #  # ]:          0 :         if ((verdict & ATA_EH_SPDN_FALLBACK_TO_PIO) && (dev->spdn_cnt >= 2) &&
    2048   [ #  #  #  # ]:          0 :             (link->ap->cbl != ATA_CBL_SATA || dev->class == ATA_DEV_ATAPI) &&
    2049         [ #  # ]:          0 :             (dev->xfer_shift != ATA_SHIFT_PIO)) {
    2050         [ #  # ]:          0 :                 if (ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO) == 0) {
    2051                 :          0 :                         dev->spdn_cnt = 0;
    2052                 :          0 :                         action |= ATA_EH_RESET;
    2053                 :          0 :                         goto done;
    2054                 :            :                 }
    2055                 :            :         }
    2056                 :            : 
    2057                 :            :         return 0;
    2058                 :          0 :  done:
    2059                 :            :         /* device has been slowed down, blow error history */
    2060         [ #  # ]:          0 :         if (!(verdict & ATA_EH_SPDN_KEEP_ERRORS))
    2061                 :          0 :                 ata_ering_clear(&dev->ering);
    2062                 :            :         return action;
    2063                 :            : }
    2064                 :            : 
    2065                 :            : /**
    2066                 :            :  *      ata_eh_worth_retry - analyze error and decide whether to retry
    2067                 :            :  *      @qc: qc to possibly retry
    2068                 :            :  *
    2069                 :            :  *      Look at the cause of the error and decide if a retry
    2070                 :            :  *      might be useful or not.  We don't want to retry media errors
    2071                 :            :  *      because the drive itself has probably already taken 10-30 seconds
    2072                 :            :  *      doing its own internal retries before reporting the failure.
    2073                 :            :  */
    2074                 :          0 : static inline int ata_eh_worth_retry(struct ata_queued_cmd *qc)
    2075                 :            : {
    2076                 :          0 :         if (qc->err_mask & AC_ERR_MEDIA)
    2077                 :            :                 return 0;       /* don't retry media errors */
    2078         [ #  # ]:          0 :         if (qc->flags & ATA_QCFLAG_IO)
    2079                 :            :                 return 1;       /* otherwise retry anything from fs stack */
    2080         [ #  # ]:          0 :         if (qc->err_mask & AC_ERR_INVALID)
    2081                 :            :                 return 0;       /* don't retry these */
    2082                 :          0 :         return qc->err_mask != AC_ERR_DEV;  /* retry if not dev error */
    2083                 :            : }
    2084                 :            : 
    2085                 :            : /**
    2086                 :            :  *      ata_eh_quiet - check if we need to be quiet about a command error
    2087                 :            :  *      @qc: qc to check
    2088                 :            :  *
    2089                 :            :  *      Look at the qc flags anbd its scsi command request flags to determine
    2090                 :            :  *      if we need to be quiet about the command failure.
    2091                 :            :  */
    2092                 :         29 : static inline bool ata_eh_quiet(struct ata_queued_cmd *qc)
    2093                 :            : {
    2094                 :         58 :         if (qc->scsicmd &&
    2095         [ +  - ]:         29 :             qc->scsicmd->request->rq_flags & RQF_QUIET)
    2096                 :         29 :                 qc->flags |= ATA_QCFLAG_QUIET;
    2097                 :         29 :         return qc->flags & ATA_QCFLAG_QUIET;
    2098                 :            : }
    2099                 :            : 
    2100                 :            : /**
    2101                 :            :  *      ata_eh_link_autopsy - analyze error and determine recovery action
    2102                 :            :  *      @link: host link to perform autopsy on
    2103                 :            :  *
    2104                 :            :  *      Analyze why @link failed and determine which recovery actions
    2105                 :            :  *      are needed.  This function also sets more detailed AC_ERR_*
    2106                 :            :  *      values and fills sense data for ATAPI CHECK SENSE.
    2107                 :            :  *
    2108                 :            :  *      LOCKING:
    2109                 :            :  *      Kernel thread context (may sleep).
    2110                 :            :  */
    2111                 :         38 : static void ata_eh_link_autopsy(struct ata_link *link)
    2112                 :            : {
    2113                 :         38 :         struct ata_port *ap = link->ap;
    2114                 :         38 :         struct ata_eh_context *ehc = &link->eh_context;
    2115                 :         38 :         struct ata_queued_cmd *qc;
    2116                 :         38 :         struct ata_device *dev;
    2117                 :         38 :         unsigned int all_err_mask = 0, eflags = 0;
    2118                 :         38 :         int tag, nr_failed = 0, nr_quiet = 0;
    2119                 :         38 :         u32 serror;
    2120                 :         38 :         int rc;
    2121                 :            : 
    2122                 :         38 :         DPRINTK("ENTER\n");
    2123                 :            : 
    2124         [ +  + ]:         38 :         if (ehc->i.flags & ATA_EHI_NO_AUTOPSY)
    2125                 :          6 :                 return;
    2126                 :            : 
    2127                 :            :         /* obtain and analyze SError */
    2128                 :         32 :         rc = sata_scr_read(link, SCR_ERROR, &serror);
    2129         [ -  + ]:         32 :         if (rc == 0) {
    2130                 :          0 :                 ehc->i.serror |= serror;
    2131                 :          0 :                 ata_eh_analyze_serror(link);
    2132         [ -  + ]:         32 :         } else if (rc != -EOPNOTSUPP) {
    2133                 :            :                 /* SError read failed, force reset and probing */
    2134                 :          0 :                 ehc->i.probe_mask |= ATA_ALL_DEVICES;
    2135                 :          0 :                 ehc->i.action |= ATA_EH_RESET;
    2136                 :          0 :                 ehc->i.err_mask |= AC_ERR_OTHER;
    2137                 :            :         }
    2138                 :            : 
    2139                 :            :         /* analyze NCQ failure */
    2140                 :         32 :         ata_eh_analyze_ncq_error(link);
    2141                 :            : 
    2142                 :            :         /* any real error trumps AC_ERR_OTHER */
    2143         [ -  + ]:         32 :         if (ehc->i.err_mask & ~AC_ERR_OTHER)
    2144                 :          0 :                 ehc->i.err_mask &= ~AC_ERR_OTHER;
    2145                 :            : 
    2146                 :         32 :         all_err_mask |= ehc->i.err_mask;
    2147                 :            : 
    2148   [ +  +  +  - ]:       1056 :         ata_qc_for_each_raw(ap, qc, tag) {
    2149   [ -  +  +  + ]:       1053 :                 if (!(qc->flags & ATA_QCFLAG_FAILED) ||
    2150                 :         29 :                     ata_dev_phys_link(qc->dev) != link)
    2151                 :        995 :                         continue;
    2152                 :            : 
    2153                 :            :                 /* inherit upper level err_mask */
    2154                 :         29 :                 qc->err_mask |= ehc->i.err_mask;
    2155                 :            : 
    2156                 :            :                 /* analyze TF */
    2157                 :         29 :                 ehc->i.action |= ata_eh_analyze_tf(qc, &qc->result_tf);
    2158                 :            : 
    2159                 :            :                 /* DEV errors are probably spurious in case of ATA_BUS error */
    2160         [ -  + ]:         29 :                 if (qc->err_mask & AC_ERR_ATA_BUS)
    2161                 :          0 :                         qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_MEDIA |
    2162                 :            :                                           AC_ERR_INVALID);
    2163                 :            : 
    2164                 :            :                 /* any real error trumps unknown error */
    2165         [ +  - ]:         29 :                 if (qc->err_mask & ~AC_ERR_OTHER)
    2166                 :         29 :                         qc->err_mask &= ~AC_ERR_OTHER;
    2167                 :            : 
    2168                 :            :                 /*
    2169                 :            :                  * SENSE_VALID trumps dev/unknown error and revalidation. Upper
    2170                 :            :                  * layers will determine whether the command is worth retrying
    2171                 :            :                  * based on the sense data and device class/type. Otherwise,
    2172                 :            :                  * determine directly if the command is worth retrying using its
    2173                 :            :                  * error mask and flags.
    2174                 :            :                  */
    2175         [ +  - ]:         29 :                 if (qc->flags & ATA_QCFLAG_SENSE_VALID)
    2176                 :         29 :                         qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_OTHER);
    2177   [ #  #  #  # ]:          0 :                 else if (ata_eh_worth_retry(qc))
    2178                 :          0 :                         qc->flags |= ATA_QCFLAG_RETRY;
    2179                 :            : 
    2180                 :            :                 /* accumulate error info */
    2181                 :         29 :                 ehc->i.dev = qc->dev;
    2182                 :         29 :                 all_err_mask |= qc->err_mask;
    2183         [ -  + ]:         29 :                 if (qc->flags & ATA_QCFLAG_IO)
    2184                 :          0 :                         eflags |= ATA_EFLAG_IS_IO;
    2185                 :         29 :                 trace_ata_eh_link_autopsy_qc(qc);
    2186                 :            : 
    2187                 :            :                 /* Count quiet errors */
    2188   [ +  -  +  - ]:         58 :                 if (ata_eh_quiet(qc))
    2189                 :         29 :                         nr_quiet++;
    2190                 :         29 :                 nr_failed++;
    2191                 :            :         }
    2192                 :            : 
    2193                 :            :         /* If all failed commands requested silence, then be quiet */
    2194         [ +  - ]:         32 :         if (nr_quiet == nr_failed)
    2195                 :         32 :                 ehc->i.flags |= ATA_EHI_QUIET;
    2196                 :            : 
    2197                 :            :         /* enforce default EH actions */
    2198         [ +  - ]:         32 :         if (ap->pflags & ATA_PFLAG_FROZEN ||
    2199         [ -  + ]:         32 :             all_err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT))
    2200                 :          0 :                 ehc->i.action |= ATA_EH_RESET;
    2201   [ -  +  -  -  :         32 :         else if (((eflags & ATA_EFLAG_IS_IO) && all_err_mask) ||
                   +  - ]
    2202         [ -  + ]:         32 :                  (!(eflags & ATA_EFLAG_IS_IO) && (all_err_mask & ~AC_ERR_DEV)))
    2203                 :          0 :                 ehc->i.action |= ATA_EH_REVALIDATE;
    2204                 :            : 
    2205                 :            :         /* If we have offending qcs and the associated failed device,
    2206                 :            :          * perform per-dev EH action only on the offending device.
    2207                 :            :          */
    2208         [ +  + ]:         32 :         if (ehc->i.dev) {
    2209                 :         29 :                 ehc->i.dev_action[ehc->i.dev->devno] |=
    2210                 :         29 :                         ehc->i.action & ATA_EH_PERDEV_MASK;
    2211                 :         29 :                 ehc->i.action &= ~ATA_EH_PERDEV_MASK;
    2212                 :            :         }
    2213                 :            : 
    2214                 :            :         /* propagate timeout to host link */
    2215   [ -  +  -  - ]:         32 :         if ((all_err_mask & AC_ERR_TIMEOUT) && !ata_is_host_link(link))
    2216                 :          0 :                 ap->link.eh_context.i.err_mask |= AC_ERR_TIMEOUT;
    2217                 :            : 
    2218                 :            :         /* record error and consider speeding down */
    2219                 :         32 :         dev = ehc->i.dev;
    2220   [ +  +  -  +  :         35 :         if (!dev && ((ata_link_max_devices(link) == 1 &&
                   -  - ]
    2221         [ #  # ]:          0 :                       ata_dev_enabled(link->device))))
    2222                 :          0 :             dev = link->device;
    2223                 :            : 
    2224         [ +  + ]:         32 :         if (dev) {
    2225         [ -  + ]:         29 :                 if (dev->flags & ATA_DFLAG_DUBIOUS_XFER)
    2226                 :          0 :                         eflags |= ATA_EFLAG_DUBIOUS_XFER;
    2227                 :         29 :                 ehc->i.action |= ata_eh_speed_down(dev, eflags, all_err_mask);
    2228                 :         29 :                 trace_ata_eh_link_autopsy(dev, ehc->i.action, all_err_mask);
    2229                 :            :         }
    2230                 :         32 :         DPRINTK("EXIT\n");
    2231                 :            : }
    2232                 :            : 
    2233                 :            : /**
    2234                 :            :  *      ata_eh_autopsy - analyze error and determine recovery action
    2235                 :            :  *      @ap: host port to perform autopsy on
    2236                 :            :  *
    2237                 :            :  *      Analyze all links of @ap and determine why they failed and
    2238                 :            :  *      which recovery actions are needed.
    2239                 :            :  *
    2240                 :            :  *      LOCKING:
    2241                 :            :  *      Kernel thread context (may sleep).
    2242                 :            :  */
    2243                 :         38 : void ata_eh_autopsy(struct ata_port *ap)
    2244                 :            : {
    2245                 :         38 :         struct ata_link *link;
    2246                 :            : 
    2247         [ +  + ]:         76 :         ata_for_each_link(link, ap, EDGE)
    2248                 :         38 :                 ata_eh_link_autopsy(link);
    2249                 :            : 
    2250                 :            :         /* Handle the frigging slave link.  Autopsy is done similarly
    2251                 :            :          * but actions and flags are transferred over to the master
    2252                 :            :          * link and handled from there.
    2253                 :            :          */
    2254         [ -  + ]:         38 :         if (ap->slave_link) {
    2255                 :          0 :                 struct ata_eh_context *mehc = &ap->link.eh_context;
    2256                 :          0 :                 struct ata_eh_context *sehc = &ap->slave_link->eh_context;
    2257                 :            : 
    2258                 :            :                 /* transfer control flags from master to slave */
    2259                 :          0 :                 sehc->i.flags |= mehc->i.flags & ATA_EHI_TO_SLAVE_MASK;
    2260                 :            : 
    2261                 :            :                 /* perform autopsy on the slave link */
    2262                 :          0 :                 ata_eh_link_autopsy(ap->slave_link);
    2263                 :            : 
    2264                 :            :                 /* transfer actions from slave to master and clear slave */
    2265                 :          0 :                 ata_eh_about_to_do(ap->slave_link, NULL, ATA_EH_ALL_ACTIONS);
    2266                 :          0 :                 mehc->i.action               |= sehc->i.action;
    2267                 :          0 :                 mehc->i.dev_action[1]        |= sehc->i.dev_action[1];
    2268                 :          0 :                 mehc->i.flags                |= sehc->i.flags;
    2269                 :          0 :                 ata_eh_done(ap->slave_link, NULL, ATA_EH_ALL_ACTIONS);
    2270                 :            :         }
    2271                 :            : 
    2272                 :            :         /* Autopsy of fanout ports can affect host link autopsy.
    2273                 :            :          * Perform host link autopsy last.
    2274                 :            :          */
    2275         [ -  + ]:         38 :         if (sata_pmp_attached(ap))
    2276                 :          0 :                 ata_eh_link_autopsy(&ap->link);
    2277                 :         38 : }
    2278                 :            : 
    2279                 :            : /**
    2280                 :            :  *      ata_get_cmd_descript - get description for ATA command
    2281                 :            :  *      @command: ATA command code to get description for
    2282                 :            :  *
    2283                 :            :  *      Return a textual description of the given command, or NULL if the
    2284                 :            :  *      command is not known.
    2285                 :            :  *
    2286                 :            :  *      LOCKING:
    2287                 :            :  *      None
    2288                 :            :  */
    2289                 :          0 : const char *ata_get_cmd_descript(u8 command)
    2290                 :            : {
    2291                 :            : #ifdef CONFIG_ATA_VERBOSE_ERROR
    2292                 :          0 :         static const struct
    2293                 :            :         {
    2294                 :            :                 u8 command;
    2295                 :            :                 const char *text;
    2296                 :            :         } cmd_descr[] = {
    2297                 :            :                 { ATA_CMD_DEV_RESET,            "DEVICE RESET" },
    2298                 :            :                 { ATA_CMD_CHK_POWER,            "CHECK POWER MODE" },
    2299                 :            :                 { ATA_CMD_STANDBY,              "STANDBY" },
    2300                 :            :                 { ATA_CMD_IDLE,                 "IDLE" },
    2301                 :            :                 { ATA_CMD_EDD,                  "EXECUTE DEVICE DIAGNOSTIC" },
    2302                 :            :                 { ATA_CMD_DOWNLOAD_MICRO,       "DOWNLOAD MICROCODE" },
    2303                 :            :                 { ATA_CMD_DOWNLOAD_MICRO_DMA,   "DOWNLOAD MICROCODE DMA" },
    2304                 :            :                 { ATA_CMD_NOP,                  "NOP" },
    2305                 :            :                 { ATA_CMD_FLUSH,                "FLUSH CACHE" },
    2306                 :            :                 { ATA_CMD_FLUSH_EXT,            "FLUSH CACHE EXT" },
    2307                 :            :                 { ATA_CMD_ID_ATA,               "IDENTIFY DEVICE" },
    2308                 :            :                 { ATA_CMD_ID_ATAPI,             "IDENTIFY PACKET DEVICE" },
    2309                 :            :                 { ATA_CMD_SERVICE,              "SERVICE" },
    2310                 :            :                 { ATA_CMD_READ,                 "READ DMA" },
    2311                 :            :                 { ATA_CMD_READ_EXT,             "READ DMA EXT" },
    2312                 :            :                 { ATA_CMD_READ_QUEUED,          "READ DMA QUEUED" },
    2313                 :            :                 { ATA_CMD_READ_STREAM_EXT,      "READ STREAM EXT" },
    2314                 :            :                 { ATA_CMD_READ_STREAM_DMA_EXT,  "READ STREAM DMA EXT" },
    2315                 :            :                 { ATA_CMD_WRITE,                "WRITE DMA" },
    2316                 :            :                 { ATA_CMD_WRITE_EXT,            "WRITE DMA EXT" },
    2317                 :            :                 { ATA_CMD_WRITE_QUEUED,         "WRITE DMA QUEUED EXT" },
    2318                 :            :                 { ATA_CMD_WRITE_STREAM_EXT,     "WRITE STREAM EXT" },
    2319                 :            :                 { ATA_CMD_WRITE_STREAM_DMA_EXT, "WRITE STREAM DMA EXT" },
    2320                 :            :                 { ATA_CMD_WRITE_FUA_EXT,        "WRITE DMA FUA EXT" },
    2321                 :            :                 { ATA_CMD_WRITE_QUEUED_FUA_EXT, "WRITE DMA QUEUED FUA EXT" },
    2322                 :            :                 { ATA_CMD_FPDMA_READ,           "READ FPDMA QUEUED" },
    2323                 :            :                 { ATA_CMD_FPDMA_WRITE,          "WRITE FPDMA QUEUED" },
    2324                 :            :                 { ATA_CMD_FPDMA_SEND,           "SEND FPDMA QUEUED" },
    2325                 :            :                 { ATA_CMD_FPDMA_RECV,           "RECEIVE FPDMA QUEUED" },
    2326                 :            :                 { ATA_CMD_PIO_READ,             "READ SECTOR(S)" },
    2327                 :            :                 { ATA_CMD_PIO_READ_EXT,         "READ SECTOR(S) EXT" },
    2328                 :            :                 { ATA_CMD_PIO_WRITE,            "WRITE SECTOR(S)" },
    2329                 :            :                 { ATA_CMD_PIO_WRITE_EXT,        "WRITE SECTOR(S) EXT" },
    2330                 :            :                 { ATA_CMD_READ_MULTI,           "READ MULTIPLE" },
    2331                 :            :                 { ATA_CMD_READ_MULTI_EXT,       "READ MULTIPLE EXT" },
    2332                 :            :                 { ATA_CMD_WRITE_MULTI,          "WRITE MULTIPLE" },
    2333                 :            :                 { ATA_CMD_WRITE_MULTI_EXT,      "WRITE MULTIPLE EXT" },
    2334                 :            :                 { ATA_CMD_WRITE_MULTI_FUA_EXT,  "WRITE MULTIPLE FUA EXT" },
    2335                 :            :                 { ATA_CMD_SET_FEATURES,         "SET FEATURES" },
    2336                 :            :                 { ATA_CMD_SET_MULTI,            "SET MULTIPLE MODE" },
    2337                 :            :                 { ATA_CMD_VERIFY,               "READ VERIFY SECTOR(S)" },
    2338                 :            :                 { ATA_CMD_VERIFY_EXT,           "READ VERIFY SECTOR(S) EXT" },
    2339                 :            :                 { ATA_CMD_WRITE_UNCORR_EXT,     "WRITE UNCORRECTABLE EXT" },
    2340                 :            :                 { ATA_CMD_STANDBYNOW1,          "STANDBY IMMEDIATE" },
    2341                 :            :                 { ATA_CMD_IDLEIMMEDIATE,        "IDLE IMMEDIATE" },
    2342                 :            :                 { ATA_CMD_SLEEP,                "SLEEP" },
    2343                 :            :                 { ATA_CMD_INIT_DEV_PARAMS,      "INITIALIZE DEVICE PARAMETERS" },
    2344                 :            :                 { ATA_CMD_READ_NATIVE_MAX,      "READ NATIVE MAX ADDRESS" },
    2345                 :            :                 { ATA_CMD_READ_NATIVE_MAX_EXT,  "READ NATIVE MAX ADDRESS EXT" },
    2346                 :            :                 { ATA_CMD_SET_MAX,              "SET MAX ADDRESS" },
    2347                 :            :                 { ATA_CMD_SET_MAX_EXT,          "SET MAX ADDRESS EXT" },
    2348                 :            :                 { ATA_CMD_READ_LOG_EXT,         "READ LOG EXT" },
    2349                 :            :                 { ATA_CMD_WRITE_LOG_EXT,        "WRITE LOG EXT" },
    2350                 :            :                 { ATA_CMD_READ_LOG_DMA_EXT,     "READ LOG DMA EXT" },
    2351                 :            :                 { ATA_CMD_WRITE_LOG_DMA_EXT,    "WRITE LOG DMA EXT" },
    2352                 :            :                 { ATA_CMD_TRUSTED_NONDATA,      "TRUSTED NON-DATA" },
    2353                 :            :                 { ATA_CMD_TRUSTED_RCV,          "TRUSTED RECEIVE" },
    2354                 :            :                 { ATA_CMD_TRUSTED_RCV_DMA,      "TRUSTED RECEIVE DMA" },
    2355                 :            :                 { ATA_CMD_TRUSTED_SND,          "TRUSTED SEND" },
    2356                 :            :                 { ATA_CMD_TRUSTED_SND_DMA,      "TRUSTED SEND DMA" },
    2357                 :            :                 { ATA_CMD_PMP_READ,             "READ BUFFER" },
    2358                 :            :                 { ATA_CMD_PMP_READ_DMA,         "READ BUFFER DMA" },
    2359                 :            :                 { ATA_CMD_PMP_WRITE,            "WRITE BUFFER" },
    2360                 :            :                 { ATA_CMD_PMP_WRITE_DMA,        "WRITE BUFFER DMA" },
    2361                 :            :                 { ATA_CMD_CONF_OVERLAY,         "DEVICE CONFIGURATION OVERLAY" },
    2362                 :            :                 { ATA_CMD_SEC_SET_PASS,         "SECURITY SET PASSWORD" },
    2363                 :            :                 { ATA_CMD_SEC_UNLOCK,           "SECURITY UNLOCK" },
    2364                 :            :                 { ATA_CMD_SEC_ERASE_PREP,       "SECURITY ERASE PREPARE" },
    2365                 :            :                 { ATA_CMD_SEC_ERASE_UNIT,       "SECURITY ERASE UNIT" },
    2366                 :            :                 { ATA_CMD_SEC_FREEZE_LOCK,      "SECURITY FREEZE LOCK" },
    2367                 :            :                 { ATA_CMD_SEC_DISABLE_PASS,     "SECURITY DISABLE PASSWORD" },
    2368                 :            :                 { ATA_CMD_CONFIG_STREAM,        "CONFIGURE STREAM" },
    2369                 :            :                 { ATA_CMD_SMART,                "SMART" },
    2370                 :            :                 { ATA_CMD_MEDIA_LOCK,           "DOOR LOCK" },
    2371                 :            :                 { ATA_CMD_MEDIA_UNLOCK,         "DOOR UNLOCK" },
    2372                 :            :                 { ATA_CMD_DSM,                  "DATA SET MANAGEMENT" },
    2373                 :            :                 { ATA_CMD_CHK_MED_CRD_TYP,      "CHECK MEDIA CARD TYPE" },
    2374                 :            :                 { ATA_CMD_CFA_REQ_EXT_ERR,      "CFA REQUEST EXTENDED ERROR" },
    2375                 :            :                 { ATA_CMD_CFA_WRITE_NE,         "CFA WRITE SECTORS WITHOUT ERASE" },
    2376                 :            :                 { ATA_CMD_CFA_TRANS_SECT,       "CFA TRANSLATE SECTOR" },
    2377                 :            :                 { ATA_CMD_CFA_ERASE,            "CFA ERASE SECTORS" },
    2378                 :            :                 { ATA_CMD_CFA_WRITE_MULT_NE,    "CFA WRITE MULTIPLE WITHOUT ERASE" },
    2379                 :            :                 { ATA_CMD_REQ_SENSE_DATA,       "REQUEST SENSE DATA EXT" },
    2380                 :            :                 { ATA_CMD_SANITIZE_DEVICE,      "SANITIZE DEVICE" },
    2381                 :            :                 { ATA_CMD_ZAC_MGMT_IN,          "ZAC MANAGEMENT IN" },
    2382                 :            :                 { ATA_CMD_ZAC_MGMT_OUT,         "ZAC MANAGEMENT OUT" },
    2383                 :            :                 { ATA_CMD_READ_LONG,            "READ LONG (with retries)" },
    2384                 :            :                 { ATA_CMD_READ_LONG_ONCE,       "READ LONG (without retries)" },
    2385                 :            :                 { ATA_CMD_WRITE_LONG,           "WRITE LONG (with retries)" },
    2386                 :            :                 { ATA_CMD_WRITE_LONG_ONCE,      "WRITE LONG (without retries)" },
    2387                 :            :                 { ATA_CMD_RESTORE,              "RECALIBRATE" },
    2388                 :            :                 { 0,                            NULL } /* terminate list */
    2389                 :            :         };
    2390                 :            : 
    2391                 :          0 :         unsigned int i;
    2392   [ #  #  #  # ]:          0 :         for (i = 0; cmd_descr[i].text; i++)
    2393   [ #  #  #  # ]:          0 :                 if (cmd_descr[i].command == command)
    2394                 :          0 :                         return cmd_descr[i].text;
    2395                 :            : #endif
    2396                 :            : 
    2397                 :            :         return NULL;
    2398                 :            : }
    2399                 :            : EXPORT_SYMBOL_GPL(ata_get_cmd_descript);
    2400                 :            : 
    2401                 :            : /**
    2402                 :            :  *      ata_eh_link_report - report error handling to user
    2403                 :            :  *      @link: ATA link EH is going on
    2404                 :            :  *
    2405                 :            :  *      Report EH to user.
    2406                 :            :  *
    2407                 :            :  *      LOCKING:
    2408                 :            :  *      None.
    2409                 :            :  */
    2410                 :         38 : static void ata_eh_link_report(struct ata_link *link)
    2411                 :            : {
    2412                 :         38 :         struct ata_port *ap = link->ap;
    2413                 :         38 :         struct ata_eh_context *ehc = &link->eh_context;
    2414                 :         38 :         struct ata_queued_cmd *qc;
    2415                 :         38 :         const char *frozen, *desc;
    2416                 :         38 :         char tries_buf[6] = "";
    2417                 :         38 :         int tag, nr_failed = 0;
    2418                 :            : 
    2419         [ -  + ]:         38 :         if (ehc->i.flags & ATA_EHI_QUIET)
    2420                 :         38 :                 return;
    2421                 :            : 
    2422                 :          0 :         desc = NULL;
    2423         [ #  # ]:          0 :         if (ehc->i.desc[0] != '\0')
    2424                 :          0 :                 desc = ehc->i.desc;
    2425                 :            : 
    2426   [ #  #  #  # ]:          0 :         ata_qc_for_each_raw(ap, qc, tag) {
    2427   [ #  #  #  # ]:          0 :                 if (!(qc->flags & ATA_QCFLAG_FAILED) ||
    2428                 :          0 :                     ata_dev_phys_link(qc->dev) != link ||
    2429         [ #  # ]:          0 :                     ((qc->flags & ATA_QCFLAG_QUIET) &&
    2430         [ #  # ]:          0 :                      qc->err_mask == AC_ERR_DEV))
    2431                 :          0 :                         continue;
    2432   [ #  #  #  # ]:          0 :                 if (qc->flags & ATA_QCFLAG_SENSE_VALID && !qc->err_mask)
    2433                 :          0 :                         continue;
    2434                 :            : 
    2435                 :          0 :                 nr_failed++;
    2436                 :            :         }
    2437                 :            : 
    2438   [ #  #  #  # ]:          0 :         if (!nr_failed && !ehc->i.err_mask)
    2439                 :            :                 return;
    2440                 :            : 
    2441                 :          0 :         frozen = "";
    2442         [ #  # ]:          0 :         if (ap->pflags & ATA_PFLAG_FROZEN)
    2443                 :          0 :                 frozen = " frozen";
    2444                 :            : 
    2445         [ #  # ]:          0 :         if (ap->eh_tries < ATA_EH_MAX_TRIES)
    2446                 :          0 :                 snprintf(tries_buf, sizeof(tries_buf), " t%d",
    2447                 :            :                          ap->eh_tries);
    2448                 :            : 
    2449         [ #  # ]:          0 :         if (ehc->i.dev) {
    2450                 :          0 :                 ata_dev_err(ehc->i.dev, "exception Emask 0x%x "
    2451                 :            :                             "SAct 0x%x SErr 0x%x action 0x%x%s%s\n",
    2452                 :            :                             ehc->i.err_mask, link->sactive, ehc->i.serror,
    2453                 :            :                             ehc->i.action, frozen, tries_buf);
    2454         [ #  # ]:          0 :                 if (desc)
    2455                 :          0 :                         ata_dev_err(ehc->i.dev, "%s\n", desc);
    2456                 :            :         } else {
    2457                 :          0 :                 ata_link_err(link, "exception Emask 0x%x "
    2458                 :            :                              "SAct 0x%x SErr 0x%x action 0x%x%s%s\n",
    2459                 :            :                              ehc->i.err_mask, link->sactive, ehc->i.serror,
    2460                 :            :                              ehc->i.action, frozen, tries_buf);
    2461         [ #  # ]:          0 :                 if (desc)
    2462                 :          0 :                         ata_link_err(link, "%s\n", desc);
    2463                 :            :         }
    2464                 :            : 
    2465                 :            : #ifdef CONFIG_ATA_VERBOSE_ERROR
    2466         [ #  # ]:          0 :         if (ehc->i.serror)
    2467   [ #  #  #  #  :          0 :                 ata_link_err(link,
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    2468                 :            :                   "SError: { %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s}\n",
    2469                 :            :                   ehc->i.serror & SERR_DATA_RECOVERED ? "RecovData " : "",
    2470                 :            :                   ehc->i.serror & SERR_COMM_RECOVERED ? "RecovComm " : "",
    2471                 :            :                   ehc->i.serror & SERR_DATA ? "UnrecovData " : "",
    2472                 :            :                   ehc->i.serror & SERR_PERSISTENT ? "Persist " : "",
    2473                 :            :                   ehc->i.serror & SERR_PROTOCOL ? "Proto " : "",
    2474                 :            :                   ehc->i.serror & SERR_INTERNAL ? "HostInt " : "",
    2475                 :            :                   ehc->i.serror & SERR_PHYRDY_CHG ? "PHYRdyChg " : "",
    2476                 :            :                   ehc->i.serror & SERR_PHY_INT_ERR ? "PHYInt " : "",
    2477                 :            :                   ehc->i.serror & SERR_COMM_WAKE ? "CommWake " : "",
    2478                 :            :                   ehc->i.serror & SERR_10B_8B_ERR ? "10B8B " : "",
    2479                 :            :                   ehc->i.serror & SERR_DISPARITY ? "Dispar " : "",
    2480                 :            :                   ehc->i.serror & SERR_CRC ? "BadCRC " : "",
    2481                 :            :                   ehc->i.serror & SERR_HANDSHAKE ? "Handshk " : "",
    2482                 :            :                   ehc->i.serror & SERR_LINK_SEQ_ERR ? "LinkSeq " : "",
    2483                 :            :                   ehc->i.serror & SERR_TRANS_ST_ERROR ? "TrStaTrns " : "",
    2484                 :            :                   ehc->i.serror & SERR_UNRECOG_FIS ? "UnrecFIS " : "",
    2485                 :            :                   ehc->i.serror & SERR_DEV_XCHG ? "DevExch " : "");
    2486                 :            : #endif
    2487                 :            : 
    2488   [ #  #  #  # ]:          0 :         ata_qc_for_each_raw(ap, qc, tag) {
    2489                 :          0 :                 struct ata_taskfile *cmd = &qc->tf, *res = &qc->result_tf;
    2490                 :          0 :                 char data_buf[20] = "";
    2491                 :          0 :                 char cdb_buf[70] = "";
    2492                 :            : 
    2493   [ #  #  #  # ]:          0 :                 if (!(qc->flags & ATA_QCFLAG_FAILED) ||
    2494         [ #  # ]:          0 :                     ata_dev_phys_link(qc->dev) != link || !qc->err_mask)
    2495                 :          0 :                         continue;
    2496                 :            : 
    2497         [ #  # ]:          0 :                 if (qc->dma_dir != DMA_NONE) {
    2498                 :          0 :                         static const char *dma_str[] = {
    2499                 :            :                                 [DMA_BIDIRECTIONAL]     = "bidi",
    2500                 :            :                                 [DMA_TO_DEVICE]         = "out",
    2501                 :            :                                 [DMA_FROM_DEVICE]       = "in",
    2502                 :            :                         };
    2503                 :          0 :                         const char *prot_str = NULL;
    2504                 :            : 
    2505   [ #  #  #  #  :          0 :                         switch (qc->tf.protocol) {
          #  #  #  #  #  
                      # ]
    2506                 :          0 :                         case ATA_PROT_UNKNOWN:
    2507                 :          0 :                                 prot_str = "unknown";
    2508                 :          0 :                                 break;
    2509                 :          0 :                         case ATA_PROT_NODATA:
    2510                 :          0 :                                 prot_str = "nodata";
    2511                 :          0 :                                 break;
    2512                 :          0 :                         case ATA_PROT_PIO:
    2513                 :          0 :                                 prot_str = "pio";
    2514                 :          0 :                                 break;
    2515                 :          0 :                         case ATA_PROT_DMA:
    2516                 :          0 :                                 prot_str = "dma";
    2517                 :          0 :                                 break;
    2518                 :          0 :                         case ATA_PROT_NCQ:
    2519                 :          0 :                                 prot_str = "ncq dma";
    2520                 :          0 :                                 break;
    2521                 :          0 :                         case ATA_PROT_NCQ_NODATA:
    2522                 :          0 :                                 prot_str = "ncq nodata";
    2523                 :          0 :                                 break;
    2524                 :          0 :                         case ATAPI_PROT_NODATA:
    2525                 :          0 :                                 prot_str = "nodata";
    2526                 :          0 :                                 break;
    2527                 :          0 :                         case ATAPI_PROT_PIO:
    2528                 :          0 :                                 prot_str = "pio";
    2529                 :          0 :                                 break;
    2530                 :          0 :                         case ATAPI_PROT_DMA:
    2531                 :          0 :                                 prot_str = "dma";
    2532                 :          0 :                                 break;
    2533                 :            :                         }
    2534                 :          0 :                         snprintf(data_buf, sizeof(data_buf), " %s %u %s",
    2535                 :            :                                  prot_str, qc->nbytes, dma_str[qc->dma_dir]);
    2536                 :            :                 }
    2537                 :            : 
    2538         [ #  # ]:          0 :                 if (ata_is_atapi(qc->tf.protocol)) {
    2539                 :          0 :                         const u8 *cdb = qc->cdb;
    2540                 :          0 :                         size_t cdb_len = qc->dev->cdb_len;
    2541                 :            : 
    2542         [ #  # ]:          0 :                         if (qc->scsicmd) {
    2543                 :          0 :                                 cdb = qc->scsicmd->cmnd;
    2544                 :          0 :                                 cdb_len = qc->scsicmd->cmd_len;
    2545                 :            :                         }
    2546                 :          0 :                         __scsi_format_command(cdb_buf, sizeof(cdb_buf),
    2547                 :            :                                               cdb, cdb_len);
    2548                 :            :                 } else {
    2549                 :          0 :                         const char *descr = ata_get_cmd_descript(cmd->command);
    2550         [ #  # ]:          0 :                         if (descr)
    2551                 :          0 :                                 ata_dev_err(qc->dev, "failed command: %s\n",
    2552                 :            :                                             descr);
    2553                 :            :                 }
    2554                 :            : 
    2555         [ #  # ]:          0 :                 ata_dev_err(qc->dev,
    2556                 :            :                         "cmd %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x "
    2557                 :            :                         "tag %d%s\n         %s"
    2558                 :            :                         "res %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x "
    2559                 :            :                         "Emask 0x%x (%s)%s\n",
    2560                 :            :                         cmd->command, cmd->feature, cmd->nsect,
    2561                 :            :                         cmd->lbal, cmd->lbam, cmd->lbah,
    2562                 :            :                         cmd->hob_feature, cmd->hob_nsect,
    2563                 :            :                         cmd->hob_lbal, cmd->hob_lbam, cmd->hob_lbah,
    2564                 :            :                         cmd->device, qc->tag, data_buf, cdb_buf,
    2565                 :            :                         res->command, res->feature, res->nsect,
    2566                 :            :                         res->lbal, res->lbam, res->lbah,
    2567                 :            :                         res->hob_feature, res->hob_nsect,
    2568                 :            :                         res->hob_lbal, res->hob_lbam, res->hob_lbah,
    2569                 :            :                         res->device, qc->err_mask, ata_err_string(qc->err_mask),
    2570                 :            :                         qc->err_mask & AC_ERR_NCQ ? " <F>" : "");
    2571                 :            : 
    2572                 :            : #ifdef CONFIG_ATA_VERBOSE_ERROR
    2573         [ #  # ]:          0 :                 if (res->command & (ATA_BUSY | ATA_DRDY | ATA_DF | ATA_DRQ |
    2574                 :            :                                     ATA_SENSE | ATA_ERR)) {
    2575         [ #  # ]:          0 :                         if (res->command & ATA_BUSY)
    2576                 :          0 :                                 ata_dev_err(qc->dev, "status: { Busy }\n");
    2577                 :            :                         else
    2578   [ #  #  #  #  :          0 :                                 ata_dev_err(qc->dev, "status: { %s%s%s%s%s}\n",
          #  #  #  #  #  
                      # ]
    2579                 :            :                                   res->command & ATA_DRDY ? "DRDY " : "",
    2580                 :            :                                   res->command & ATA_DF ? "DF " : "",
    2581                 :            :                                   res->command & ATA_DRQ ? "DRQ " : "",
    2582                 :            :                                   res->command & ATA_SENSE ? "SENSE " : "",
    2583                 :            :                                   res->command & ATA_ERR ? "ERR " : "");
    2584                 :            :                 }
    2585                 :            : 
    2586         [ #  # ]:          0 :                 if (cmd->command != ATA_CMD_PACKET &&
    2587         [ #  # ]:          0 :                     (res->feature & (ATA_ICRC | ATA_UNC | ATA_AMNF |
    2588                 :            :                                      ATA_IDNF | ATA_ABORTED)))
    2589   [ #  #  #  #  :          0 :                         ata_dev_err(qc->dev, "error: { %s%s%s%s%s}\n",
          #  #  #  #  #  
                      # ]
    2590                 :            :                           res->feature & ATA_ICRC ? "ICRC " : "",
    2591                 :            :                           res->feature & ATA_UNC ? "UNC " : "",
    2592                 :            :                           res->feature & ATA_AMNF ? "AMNF " : "",
    2593                 :            :                           res->feature & ATA_IDNF ? "IDNF " : "",
    2594                 :            :                           res->feature & ATA_ABORTED ? "ABRT " : "");
    2595                 :            : #endif
    2596                 :            :         }
    2597                 :            : }
    2598                 :            : 
    2599                 :            : /**
    2600                 :            :  *      ata_eh_report - report error handling to user
    2601                 :            :  *      @ap: ATA port to report EH about
    2602                 :            :  *
    2603                 :            :  *      Report EH to user.
    2604                 :            :  *
    2605                 :            :  *      LOCKING:
    2606                 :            :  *      None.
    2607                 :            :  */
    2608                 :         38 : void ata_eh_report(struct ata_port *ap)
    2609                 :            : {
    2610                 :         38 :         struct ata_link *link;
    2611                 :            : 
    2612         [ +  + ]:         76 :         ata_for_each_link(link, ap, HOST_FIRST)
    2613                 :         38 :                 ata_eh_link_report(link);
    2614                 :         38 : }
    2615                 :            : 
    2616                 :          6 : static int ata_do_reset(struct ata_link *link, ata_reset_fn_t reset,
    2617                 :            :                         unsigned int *classes, unsigned long deadline,
    2618                 :            :                         bool clear_classes)
    2619                 :            : {
    2620                 :          6 :         struct ata_device *dev;
    2621                 :            : 
    2622         [ +  - ]:          6 :         if (clear_classes)
    2623         [ +  + ]:         18 :                 ata_for_each_dev(dev, link, ALL)
    2624                 :         12 :                         classes[dev->devno] = ATA_DEV_UNKNOWN;
    2625                 :            : 
    2626                 :          6 :         return reset(link, classes, deadline);
    2627                 :            : }
    2628                 :            : 
    2629                 :          0 : static int ata_eh_followup_srst_needed(struct ata_link *link, int rc)
    2630                 :            : {
    2631   [ #  #  #  # ]:          0 :         if ((link->flags & ATA_LFLAG_NO_SRST) || ata_link_offline(link))
    2632                 :          0 :                 return 0;
    2633         [ #  # ]:          0 :         if (rc == -EAGAIN)
    2634                 :            :                 return 1;
    2635   [ #  #  #  # ]:          0 :         if (sata_pmp_supported(link->ap) && ata_is_host_link(link))
    2636                 :          0 :                 return 1;
    2637                 :            :         return 0;
    2638                 :            : }
    2639                 :            : 
    2640                 :          6 : int ata_eh_reset(struct ata_link *link, int classify,
    2641                 :            :                  ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
    2642                 :            :                  ata_reset_fn_t hardreset, ata_postreset_fn_t postreset)
    2643                 :            : {
    2644                 :          6 :         struct ata_port *ap = link->ap;
    2645                 :          6 :         struct ata_link *slave = ap->slave_link;
    2646                 :          6 :         struct ata_eh_context *ehc = &link->eh_context;
    2647         [ -  + ]:          6 :         struct ata_eh_context *sehc = slave ? &slave->eh_context : NULL;
    2648                 :          6 :         unsigned int *classes = ehc->classes;
    2649                 :          6 :         unsigned int lflags = link->flags;
    2650                 :          6 :         int verbose = !(ehc->i.flags & ATA_EHI_QUIET);
    2651                 :          6 :         int max_tries = 0, try = 0;
    2652                 :          6 :         struct ata_link *failed_link;
    2653                 :          6 :         struct ata_device *dev;
    2654                 :          6 :         unsigned long deadline, now;
    2655                 :          6 :         ata_reset_fn_t reset;
    2656                 :          6 :         unsigned long flags;
    2657                 :          6 :         u32 sstatus;
    2658                 :          6 :         int nr_unknown, rc;
    2659                 :            : 
    2660                 :            :         /*
    2661                 :            :          * Prepare to reset
    2662                 :            :          */
    2663         [ +  + ]:         30 :         while (ata_eh_reset_timeouts[max_tries] != ULONG_MAX)
    2664                 :         24 :                 max_tries++;
    2665         [ -  + ]:          6 :         if (link->flags & ATA_LFLAG_RST_ONCE)
    2666                 :          0 :                 max_tries = 1;
    2667         [ -  + ]:          6 :         if (link->flags & ATA_LFLAG_NO_HRST)
    2668                 :          0 :                 hardreset = NULL;
    2669         [ -  + ]:          6 :         if (link->flags & ATA_LFLAG_NO_SRST)
    2670                 :          0 :                 softreset = NULL;
    2671                 :            : 
    2672                 :            :         /* make sure each reset attempt is at least COOL_DOWN apart */
    2673         [ -  + ]:          6 :         if (ehc->i.flags & ATA_EHI_DID_RESET) {
    2674                 :          0 :                 now = jiffies;
    2675   [ #  #  #  # ]:          0 :                 WARN_ON(time_after(ehc->last_reset, now));
    2676         [ #  # ]:          0 :                 deadline = ata_deadline(ehc->last_reset,
    2677                 :            :                                         ATA_EH_RESET_COOL_DOWN);
    2678         [ #  # ]:          0 :                 if (time_before(now, deadline))
    2679                 :          0 :                         schedule_timeout_uninterruptible(deadline - now);
    2680                 :            :         }
    2681                 :            : 
    2682                 :          6 :         spin_lock_irqsave(ap->lock, flags);
    2683                 :          6 :         ap->pflags |= ATA_PFLAG_RESETTING;
    2684                 :          6 :         spin_unlock_irqrestore(ap->lock, flags);
    2685                 :            : 
    2686                 :          6 :         ata_eh_about_to_do(link, NULL, ATA_EH_RESET);
    2687                 :            : 
    2688         [ +  + ]:         18 :         ata_for_each_dev(dev, link, ALL) {
    2689                 :            :                 /* If we issue an SRST then an ATA drive (not ATAPI)
    2690                 :            :                  * may change configuration and be in PIO0 timing. If
    2691                 :            :                  * we do a hard reset (or are coming from power on)
    2692                 :            :                  * this is true for ATA or ATAPI. Until we've set a
    2693                 :            :                  * suitable controller mode we should not touch the
    2694                 :            :                  * bus as we may be talking too fast.
    2695                 :            :                  */
    2696                 :         12 :                 dev->pio_mode = XFER_PIO_0;
    2697                 :         12 :                 dev->dma_mode = 0xff;
    2698                 :            : 
    2699                 :            :                 /* If the controller has a pio mode setup function
    2700                 :            :                  * then use it to set the chipset to rights. Don't
    2701                 :            :                  * touch the DMA setup as that will be dealt with when
    2702                 :            :                  * configuring devices.
    2703                 :            :                  */
    2704         [ +  - ]:         12 :                 if (ap->ops->set_piomode)
    2705                 :         12 :                         ap->ops->set_piomode(ap, dev);
    2706                 :            :         }
    2707                 :            : 
    2708                 :            :         /* prefer hardreset */
    2709                 :          6 :         reset = NULL;
    2710                 :          6 :         ehc->i.action &= ~ATA_EH_RESET;
    2711         [ -  + ]:          6 :         if (hardreset) {
    2712                 :          0 :                 reset = hardreset;
    2713                 :          0 :                 ehc->i.action |= ATA_EH_HARDRESET;
    2714         [ +  - ]:          6 :         } else if (softreset) {
    2715                 :          6 :                 reset = softreset;
    2716                 :          6 :                 ehc->i.action |= ATA_EH_SOFTRESET;
    2717                 :            :         }
    2718                 :            : 
    2719         [ -  + ]:          6 :         if (prereset) {
    2720         [ -  + ]:          6 :                 unsigned long deadline = ata_deadline(jiffies,
    2721                 :            :                                                       ATA_EH_PRERESET_TIMEOUT);
    2722                 :            : 
    2723         [ -  + ]:          6 :                 if (slave) {
    2724                 :          0 :                         sehc->i.action &= ~ATA_EH_RESET;
    2725                 :          0 :                         sehc->i.action |= ehc->i.action;
    2726                 :            :                 }
    2727                 :            : 
    2728                 :          6 :                 rc = prereset(link, deadline);
    2729                 :            : 
    2730                 :            :                 /* If present, do prereset on slave link too.  Reset
    2731                 :            :                  * is skipped iff both master and slave links report
    2732                 :            :                  * -ENOENT or clear ATA_EH_RESET.
    2733                 :            :                  */
    2734   [ -  +  -  - ]:          6 :                 if (slave && (rc == 0 || rc == -ENOENT)) {
    2735                 :          0 :                         int tmp;
    2736                 :            : 
    2737                 :          0 :                         tmp = prereset(slave, deadline);
    2738         [ #  # ]:          0 :                         if (tmp != -ENOENT)
    2739                 :          0 :                                 rc = tmp;
    2740                 :            : 
    2741                 :          0 :                         ehc->i.action |= sehc->i.action;
    2742                 :            :                 }
    2743                 :            : 
    2744         [ -  + ]:          6 :                 if (rc) {
    2745         [ #  # ]:          0 :                         if (rc == -ENOENT) {
    2746                 :          0 :                                 ata_link_dbg(link, "port disabled--ignoring\n");
    2747                 :          0 :                                 ehc->i.action &= ~ATA_EH_RESET;
    2748                 :            : 
    2749         [ #  # ]:          0 :                                 ata_for_each_dev(dev, link, ALL)
    2750                 :          0 :                                         classes[dev->devno] = ATA_DEV_NONE;
    2751                 :            : 
    2752                 :            :                                 rc = 0;
    2753                 :            :                         } else
    2754                 :          0 :                                 ata_link_err(link,
    2755                 :            :                                              "prereset failed (errno=%d)\n",
    2756                 :            :                                              rc);
    2757                 :          0 :                         goto out;
    2758                 :            :                 }
    2759                 :            : 
    2760                 :            :                 /* prereset() might have cleared ATA_EH_RESET.  If so,
    2761                 :            :                  * bang classes, thaw and return.
    2762                 :            :                  */
    2763   [ -  +  +  - ]:          6 :                 if (reset && !(ehc->i.action & ATA_EH_RESET)) {
    2764         [ #  # ]:          0 :                         ata_for_each_dev(dev, link, ALL)
    2765                 :          0 :                                 classes[dev->devno] = ATA_DEV_NONE;
    2766   [ #  #  #  # ]:          0 :                         if ((ap->pflags & ATA_PFLAG_FROZEN) &&
    2767                 :            :                             ata_is_host_link(link))
    2768                 :          0 :                                 ata_eh_thaw_port(ap);
    2769                 :          0 :                         rc = 0;
    2770                 :          0 :                         goto out;
    2771                 :            :                 }
    2772                 :            :         }
    2773                 :            : 
    2774                 :          6 :  retry:
    2775                 :            :         /*
    2776                 :            :          * Perform reset
    2777                 :            :          */
    2778   [ -  +  +  - ]:          6 :         if (ata_is_host_link(link))
    2779                 :          6 :                 ata_eh_freeze_port(ap);
    2780                 :            : 
    2781         [ -  + ]:          6 :         deadline = ata_deadline(jiffies, ata_eh_reset_timeouts[try++]);
    2782                 :            : 
    2783         [ +  - ]:          6 :         if (reset) {
    2784         [ -  + ]:          6 :                 if (verbose)
    2785         [ #  # ]:          0 :                         ata_link_info(link, "%s resetting link\n",
    2786                 :            :                                       reset == softreset ? "soft" : "hard");
    2787                 :            : 
    2788                 :            :                 /* mark that this EH session started with reset */
    2789                 :          6 :                 ehc->last_reset = jiffies;
    2790         [ -  + ]:          6 :                 if (reset == hardreset)
    2791                 :          0 :                         ehc->i.flags |= ATA_EHI_DID_HARDRESET;
    2792                 :            :                 else
    2793                 :          6 :                         ehc->i.flags |= ATA_EHI_DID_SOFTRESET;
    2794                 :            : 
    2795                 :          6 :                 rc = ata_do_reset(link, reset, classes, deadline, true);
    2796         [ -  + ]:          6 :                 if (rc && rc != -EAGAIN) {
    2797                 :          0 :                         failed_link = link;
    2798                 :          0 :                         goto fail;
    2799                 :            :                 }
    2800                 :            : 
    2801                 :            :                 /* hardreset slave link if existent */
    2802         [ -  + ]:          6 :                 if (slave && reset == hardreset) {
    2803                 :          0 :                         int tmp;
    2804                 :            : 
    2805         [ #  # ]:          0 :                         if (verbose)
    2806                 :          0 :                                 ata_link_info(slave, "hard resetting link\n");
    2807                 :            : 
    2808                 :          0 :                         ata_eh_about_to_do(slave, NULL, ATA_EH_RESET);
    2809                 :          0 :                         tmp = ata_do_reset(slave, reset, classes, deadline,
    2810                 :            :                                            false);
    2811      [ #  #  # ]:          0 :                         switch (tmp) {
    2812                 :          0 :                         case -EAGAIN:
    2813                 :          0 :                                 rc = -EAGAIN;
    2814                 :            :                         case 0:
    2815                 :            :                                 break;
    2816                 :          0 :                         default:
    2817                 :          0 :                                 failed_link = slave;
    2818                 :          0 :                                 rc = tmp;
    2819                 :          0 :                                 goto fail;
    2820                 :            :                         }
    2821                 :          6 :                 }
    2822                 :            : 
    2823                 :            :                 /* perform follow-up SRST if necessary */
    2824   [ -  +  -  - ]:          6 :                 if (reset == hardreset &&
    2825                 :          0 :                     ata_eh_followup_srst_needed(link, rc)) {
    2826                 :          0 :                         reset = softreset;
    2827                 :            : 
    2828         [ #  # ]:          0 :                         if (!reset) {
    2829                 :          0 :                                 ata_link_err(link,
    2830                 :            :              "follow-up softreset required but no softreset available\n");
    2831                 :          0 :                                 failed_link = link;
    2832                 :          0 :                                 rc = -EINVAL;
    2833                 :          0 :                                 goto fail;
    2834                 :            :                         }
    2835                 :            : 
    2836                 :          0 :                         ata_eh_about_to_do(link, NULL, ATA_EH_RESET);
    2837                 :          0 :                         rc = ata_do_reset(link, reset, classes, deadline, true);
    2838         [ #  # ]:          0 :                         if (rc) {
    2839                 :          0 :                                 failed_link = link;
    2840                 :          0 :                                 goto fail;
    2841                 :            :                         }
    2842                 :            :                 }
    2843                 :            :         } else {
    2844         [ #  # ]:          0 :                 if (verbose)
    2845                 :          0 :                         ata_link_info(link,
    2846                 :            :         "no reset method available, skipping reset\n");
    2847         [ #  # ]:          0 :                 if (!(lflags & ATA_LFLAG_ASSUME_CLASS))
    2848                 :          0 :                         lflags |= ATA_LFLAG_ASSUME_ATA;
    2849                 :            :         }
    2850                 :            : 
    2851                 :            :         /*
    2852                 :            :          * Post-reset processing
    2853                 :            :          */
    2854         [ +  + ]:         18 :         ata_for_each_dev(dev, link, ALL) {
    2855                 :            :                 /* After the reset, the device state is PIO 0 and the
    2856                 :            :                  * controller state is undefined.  Reset also wakes up
    2857                 :            :                  * drives from sleeping mode.
    2858                 :            :                  */
    2859                 :         12 :                 dev->pio_mode = XFER_PIO_0;
    2860                 :         12 :                 dev->flags &= ~ATA_DFLAG_SLEEPING;
    2861                 :            : 
    2862         [ -  + ]:         12 :                 if (ata_phys_link_offline(ata_dev_phys_link(dev)))
    2863                 :          0 :                         continue;
    2864                 :            : 
    2865                 :            :                 /* apply class override */
    2866         [ -  + ]:         12 :                 if (lflags & ATA_LFLAG_ASSUME_ATA)
    2867                 :          0 :                         classes[dev->devno] = ATA_DEV_ATA;
    2868         [ -  + ]:         12 :                 else if (lflags & ATA_LFLAG_ASSUME_SEMB)
    2869                 :          0 :                         classes[dev->devno] = ATA_DEV_SEMB_UNSUP;
    2870                 :            :         }
    2871                 :            : 
    2872                 :            :         /* record current link speed */
    2873         [ -  + ]:          6 :         if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0)
    2874                 :          0 :                 link->sata_spd = (sstatus >> 4) & 0xf;
    2875   [ -  +  -  - ]:          6 :         if (slave && sata_scr_read(slave, SCR_STATUS, &sstatus) == 0)
    2876                 :          0 :                 slave->sata_spd = (sstatus >> 4) & 0xf;
    2877                 :            : 
    2878                 :            :         /* thaw the port */
    2879   [ -  +  +  - ]:          6 :         if (ata_is_host_link(link))
    2880                 :          6 :                 ata_eh_thaw_port(ap);
    2881                 :            : 
    2882                 :            :         /* postreset() should clear hardware SError.  Although SError
    2883                 :            :          * is cleared during link resume, clearing SError here is
    2884                 :            :          * necessary as some PHYs raise hotplug events after SRST.
    2885                 :            :          * This introduces race condition where hotplug occurs between
    2886                 :            :          * reset and here.  This race is mediated by cross checking
    2887                 :            :          * link onlineness and classification result later.
    2888                 :            :          */
    2889         [ +  - ]:          6 :         if (postreset) {
    2890                 :          6 :                 postreset(link, classes);
    2891         [ -  + ]:          6 :                 if (slave)
    2892                 :          0 :                         postreset(slave, classes);
    2893                 :            :         }
    2894                 :            : 
    2895                 :            :         /*
    2896                 :            :          * Some controllers can't be frozen very well and may set spurious
    2897                 :            :          * error conditions during reset.  Clear accumulated error
    2898                 :            :          * information and re-thaw the port if frozen.  As reset is the
    2899                 :            :          * final recovery action and we cross check link onlineness against
    2900                 :            :          * device classification later, no hotplug event is lost by this.
    2901                 :            :          */
    2902                 :          6 :         spin_lock_irqsave(link->ap->lock, flags);
    2903                 :          6 :         memset(&link->eh_info, 0, sizeof(link->eh_info));
    2904         [ -  + ]:          6 :         if (slave)
    2905                 :          0 :                 memset(&slave->eh_info, 0, sizeof(link->eh_info));
    2906                 :          6 :         ap->pflags &= ~ATA_PFLAG_EH_PENDING;
    2907                 :          6 :         spin_unlock_irqrestore(link->ap->lock, flags);
    2908                 :            : 
    2909         [ -  + ]:          6 :         if (ap->pflags & ATA_PFLAG_FROZEN)
    2910                 :          0 :                 ata_eh_thaw_port(ap);
    2911                 :            : 
    2912                 :            :         /*
    2913                 :            :          * Make sure onlineness and classification result correspond.
    2914                 :            :          * Hotplug could have happened during reset and some
    2915                 :            :          * controllers fail to wait while a drive is spinning up after
    2916                 :            :          * being hotplugged causing misdetection.  By cross checking
    2917                 :            :          * link on/offlineness and classification result, those
    2918                 :            :          * conditions can be reliably detected and retried.
    2919                 :            :          */
    2920                 :          6 :         nr_unknown = 0;
    2921         [ +  + ]:         18 :         ata_for_each_dev(dev, link, ALL) {
    2922         [ -  + ]:         12 :                 if (ata_phys_link_online(ata_dev_phys_link(dev))) {
    2923         [ #  # ]:          0 :                         if (classes[dev->devno] == ATA_DEV_UNKNOWN) {
    2924                 :          0 :                                 ata_dev_dbg(dev, "link online but device misclassified\n");
    2925                 :          0 :                                 classes[dev->devno] = ATA_DEV_NONE;
    2926                 :          0 :                                 nr_unknown++;
    2927                 :            :                         }
    2928         [ -  + ]:         12 :                 } else if (ata_phys_link_offline(ata_dev_phys_link(dev))) {
    2929   [ #  #  #  # ]:          0 :                         if (ata_class_enabled(classes[dev->devno]))
    2930                 :          0 :                                 ata_dev_dbg(dev,
    2931                 :            :                                             "link offline, clearing class %d to NONE\n",
    2932                 :            :                                             classes[dev->devno]);
    2933                 :          0 :                         classes[dev->devno] = ATA_DEV_NONE;
    2934         [ -  + ]:         12 :                 } else if (classes[dev->devno] == ATA_DEV_UNKNOWN) {
    2935                 :          0 :                         ata_dev_dbg(dev,
    2936                 :            :                                     "link status unknown, clearing UNKNOWN to NONE\n");
    2937                 :          0 :                         classes[dev->devno] = ATA_DEV_NONE;
    2938                 :            :                 }
    2939                 :            :         }
    2940                 :            : 
    2941         [ -  + ]:          6 :         if (classify && nr_unknown) {
    2942         [ #  # ]:          0 :                 if (try < max_tries) {
    2943                 :          0 :                         ata_link_warn(link,
    2944                 :            :                                       "link online but %d devices misclassified, retrying\n",
    2945                 :            :                                       nr_unknown);
    2946                 :          0 :                         failed_link = link;
    2947                 :          0 :                         rc = -EAGAIN;
    2948                 :          0 :                         goto fail;
    2949                 :            :                 }
    2950                 :          0 :                 ata_link_warn(link,
    2951                 :            :                               "link online but %d devices misclassified, "
    2952                 :            :                               "device detection might fail\n", nr_unknown);
    2953                 :            :         }
    2954                 :            : 
    2955                 :            :         /* reset successful, schedule revalidation */
    2956                 :          6 :         ata_eh_done(link, NULL, ATA_EH_RESET);
    2957         [ -  + ]:          6 :         if (slave)
    2958                 :          0 :                 ata_eh_done(slave, NULL, ATA_EH_RESET);
    2959                 :          6 :         ehc->last_reset = jiffies;           /* update to completion time */
    2960                 :          6 :         ehc->i.action |= ATA_EH_REVALIDATE;
    2961                 :          6 :         link->lpm_policy = ATA_LPM_UNKNOWN;  /* reset LPM state */
    2962                 :            : 
    2963                 :          6 :         rc = 0;
    2964                 :          6 :  out:
    2965                 :            :         /* clear hotplug flag */
    2966                 :          6 :         ehc->i.flags &= ~ATA_EHI_HOTPLUGGED;
    2967         [ -  + ]:          6 :         if (slave)
    2968                 :          0 :                 sehc->i.flags &= ~ATA_EHI_HOTPLUGGED;
    2969                 :            : 
    2970                 :          6 :         spin_lock_irqsave(ap->lock, flags);
    2971                 :          6 :         ap->pflags &= ~ATA_PFLAG_RESETTING;
    2972                 :          6 :         spin_unlock_irqrestore(ap->lock, flags);
    2973                 :            : 
    2974                 :          6 :         return rc;
    2975                 :            : 
    2976                 :          0 :  fail:
    2977                 :            :         /* if SCR isn't accessible on a fan-out port, PMP needs to be reset */
    2978   [ #  #  #  #  :          0 :         if (!ata_is_host_link(link) &&
                   #  # ]
    2979                 :          0 :             sata_scr_read(link, SCR_STATUS, &sstatus))
    2980                 :          0 :                 rc = -ERESTART;
    2981                 :            : 
    2982         [ #  # ]:          0 :         if (try >= max_tries) {
    2983                 :            :                 /*
    2984                 :            :                  * Thaw host port even if reset failed, so that the port
    2985                 :            :                  * can be retried on the next phy event.  This risks
    2986                 :            :                  * repeated EH runs but seems to be a better tradeoff than
    2987                 :            :                  * shutting down a port after a botched hotplug attempt.
    2988                 :            :                  */
    2989   [ #  #  #  # ]:          0 :                 if (ata_is_host_link(link))
    2990                 :          0 :                         ata_eh_thaw_port(ap);
    2991                 :          0 :                 goto out;
    2992                 :            :         }
    2993                 :            : 
    2994                 :          0 :         now = jiffies;
    2995         [ #  # ]:          0 :         if (time_before(now, deadline)) {
    2996                 :          0 :                 unsigned long delta = deadline - now;
    2997                 :            : 
    2998                 :          0 :                 ata_link_warn(failed_link,
    2999                 :            :                         "reset failed (errno=%d), retrying in %u secs\n",
    3000                 :            :                         rc, DIV_ROUND_UP(jiffies_to_msecs(delta), 1000));
    3001                 :            : 
    3002                 :          0 :                 ata_eh_release(ap);
    3003         [ #  # ]:          0 :                 while (delta)
    3004                 :          0 :                         delta = schedule_timeout_uninterruptible(delta);
    3005                 :          0 :                 ata_eh_acquire(ap);
    3006                 :            :         }
    3007                 :            : 
    3008                 :            :         /*
    3009                 :            :          * While disks spinup behind PMP, some controllers fail sending SRST.
    3010                 :            :          * They need to be reset - as well as the PMP - before retrying.
    3011                 :            :          */
    3012         [ #  # ]:          0 :         if (rc == -ERESTART) {
    3013   [ #  #  #  # ]:          0 :                 if (ata_is_host_link(link))
    3014                 :          0 :                         ata_eh_thaw_port(ap);
    3015                 :          0 :                 goto out;
    3016                 :            :         }
    3017                 :            : 
    3018         [ #  # ]:          0 :         if (try == max_tries - 1) {
    3019                 :          0 :                 sata_down_spd_limit(link, 0);
    3020         [ #  # ]:          0 :                 if (slave)
    3021                 :          0 :                         sata_down_spd_limit(slave, 0);
    3022         [ #  # ]:          0 :         } else if (rc == -EPIPE)
    3023                 :          0 :                 sata_down_spd_limit(failed_link, 0);
    3024                 :            : 
    3025         [ #  # ]:          0 :         if (hardreset)
    3026                 :          0 :                 reset = hardreset;
    3027                 :          0 :         goto retry;
    3028                 :            : }
    3029                 :            : 
    3030                 :         38 : static inline void ata_eh_pull_park_action(struct ata_port *ap)
    3031                 :            : {
    3032                 :         38 :         struct ata_link *link;
    3033                 :         38 :         struct ata_device *dev;
    3034                 :         38 :         unsigned long flags;
    3035                 :            : 
    3036                 :            :         /*
    3037                 :            :          * This function can be thought of as an extended version of
    3038                 :            :          * ata_eh_about_to_do() specially crafted to accommodate the
    3039                 :            :          * requirements of ATA_EH_PARK handling. Since the EH thread
    3040                 :            :          * does not leave the do {} while () loop in ata_eh_recover as
    3041                 :            :          * long as the timeout for a park request to *one* device on
    3042                 :            :          * the port has not expired, and since we still want to pick
    3043                 :            :          * up park requests to other devices on the same port or
    3044                 :            :          * timeout updates for the same device, we have to pull
    3045                 :            :          * ATA_EH_PARK actions from eh_info into eh_context.i
    3046                 :            :          * ourselves at the beginning of each pass over the loop.
    3047                 :            :          *
    3048                 :            :          * Additionally, all write accesses to &ap->park_req_pending
    3049                 :            :          * through reinit_completion() (see below) or complete_all()
    3050                 :            :          * (see ata_scsi_park_store()) are protected by the host lock.
    3051                 :            :          * As a result we have that park_req_pending.done is zero on
    3052                 :            :          * exit from this function, i.e. when ATA_EH_PARK actions for
    3053                 :            :          * *all* devices on port ap have been pulled into the
    3054                 :            :          * respective eh_context structs. If, and only if,
    3055                 :            :          * park_req_pending.done is non-zero by the time we reach
    3056                 :            :          * wait_for_completion_timeout(), another ATA_EH_PARK action
    3057                 :            :          * has been scheduled for at least one of the devices on port
    3058                 :            :          * ap and we have to cycle over the do {} while () loop in
    3059                 :            :          * ata_eh_recover() again.
    3060                 :            :          */
    3061                 :            : 
    3062                 :         38 :         spin_lock_irqsave(ap->lock, flags);
    3063                 :         38 :         reinit_completion(&ap->park_req_pending);
    3064         [ +  + ]:         76 :         ata_for_each_link(link, ap, EDGE) {
    3065         [ +  + ]:        114 :                 ata_for_each_dev(dev, link, ALL) {
    3066                 :         76 :                         struct ata_eh_info *ehi = &link->eh_info;
    3067                 :            : 
    3068                 :         76 :                         link->eh_context.i.dev_action[dev->devno] |=
    3069                 :         76 :                                 ehi->dev_action[dev->devno] & ATA_EH_PARK;
    3070                 :         76 :                         ata_eh_clear_action(link, dev, ehi, ATA_EH_PARK);
    3071                 :            :                 }
    3072                 :            :         }
    3073                 :         38 :         spin_unlock_irqrestore(ap->lock, flags);
    3074                 :         38 : }
    3075                 :            : 
    3076                 :          0 : static void ata_eh_park_issue_cmd(struct ata_device *dev, int park)
    3077                 :            : {
    3078                 :          0 :         struct ata_eh_context *ehc = &dev->link->eh_context;
    3079                 :          0 :         struct ata_taskfile tf;
    3080                 :          0 :         unsigned int err_mask;
    3081                 :            : 
    3082         [ #  # ]:          0 :         ata_tf_init(dev, &tf);
    3083         [ #  # ]:          0 :         if (park) {
    3084                 :          0 :                 ehc->unloaded_mask |= 1 << dev->devno;
    3085                 :          0 :                 tf.command = ATA_CMD_IDLEIMMEDIATE;
    3086                 :          0 :                 tf.feature = 0x44;
    3087                 :          0 :                 tf.lbal = 0x4c;
    3088                 :          0 :                 tf.lbam = 0x4e;
    3089                 :          0 :                 tf.lbah = 0x55;
    3090                 :            :         } else {
    3091                 :          0 :                 ehc->unloaded_mask &= ~(1 << dev->devno);
    3092                 :          0 :                 tf.command = ATA_CMD_CHK_POWER;
    3093                 :            :         }
    3094                 :            : 
    3095                 :          0 :         tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
    3096                 :          0 :         tf.protocol = ATA_PROT_NODATA;
    3097                 :          0 :         err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
    3098   [ #  #  #  #  :          0 :         if (park && (err_mask || tf.lbal != 0xc4)) {
                   #  # ]
    3099                 :          0 :                 ata_dev_err(dev, "head unload failed!\n");
    3100                 :          0 :                 ehc->unloaded_mask &= ~(1 << dev->devno);
    3101                 :            :         }
    3102                 :          0 : }
    3103                 :            : 
    3104                 :         38 : static int ata_eh_revalidate_and_attach(struct ata_link *link,
    3105                 :            :                                         struct ata_device **r_failed_dev)
    3106                 :            : {
    3107                 :         38 :         struct ata_port *ap = link->ap;
    3108                 :         38 :         struct ata_eh_context *ehc = &link->eh_context;
    3109                 :         38 :         struct ata_device *dev;
    3110                 :         38 :         unsigned int new_mask = 0;
    3111                 :         38 :         unsigned long flags;
    3112                 :         38 :         int rc = 0;
    3113                 :            : 
    3114                 :         38 :         DPRINTK("ENTER\n");
    3115                 :            : 
    3116                 :            :         /* For PATA drive side cable detection to work, IDENTIFY must
    3117                 :            :          * be done backwards such that PDIAG- is released by the slave
    3118                 :            :          * device before the master device is identified.
    3119                 :            :          */
    3120         [ +  + ]:        114 :         ata_for_each_dev(dev, link, ALL_REVERSE) {
    3121                 :         76 :                 unsigned int action = ata_eh_dev_action(dev);
    3122                 :         76 :                 unsigned int readid_flags = 0;
    3123                 :            : 
    3124         [ +  + ]:         76 :                 if (ehc->i.flags & ATA_EHI_DID_RESET)
    3125                 :         12 :                         readid_flags |= ATA_READID_POSTRESET;
    3126                 :            : 
    3127   [ +  +  +  -  :         88 :                 if ((action & ATA_EH_REVALIDATE) && ata_dev_enabled(dev)) {
                   -  + ]
    3128         [ #  # ]:          0 :                         WARN_ON(dev->class == ATA_DEV_PMP);
    3129                 :            : 
    3130         [ #  # ]:          0 :                         if (ata_phys_link_offline(ata_dev_phys_link(dev))) {
    3131                 :          0 :                                 rc = -EIO;
    3132                 :          0 :                                 goto err;
    3133                 :            :                         }
    3134                 :            : 
    3135                 :          0 :                         ata_eh_about_to_do(link, dev, ATA_EH_REVALIDATE);
    3136                 :          0 :                         rc = ata_dev_revalidate(dev, ehc->classes[dev->devno],
    3137                 :            :                                                 readid_flags);
    3138         [ #  # ]:          0 :                         if (rc)
    3139                 :          0 :                                 goto err;
    3140                 :            : 
    3141                 :          0 :                         ata_eh_done(link, dev, ATA_EH_REVALIDATE);
    3142                 :            : 
    3143                 :            :                         /* Configuration may have changed, reconfigure
    3144                 :            :                          * transfer mode.
    3145                 :            :                          */
    3146                 :          0 :                         ehc->i.flags |= ATA_EHI_SETMODE;
    3147                 :            : 
    3148                 :            :                         /* schedule the scsi_rescan_device() here */
    3149                 :          0 :                         schedule_work(&(ap->scsi_rescan_task));
    3150         [ +  + ]:         76 :                 } else if (dev->class == ATA_DEV_UNKNOWN &&
    3151   [ -  +  +  + ]:         88 :                            ehc->tries[dev->devno] &&
    3152         [ +  + ]:         44 :                            ata_class_enabled(ehc->classes[dev->devno])) {
    3153                 :            :                         /* Temporarily set dev->class, it will be
    3154                 :            :                          * permanently set once all configurations are
    3155                 :            :                          * complete.  This is necessary because new
    3156                 :            :                          * device configuration is done in two
    3157                 :            :                          * separate loops.
    3158                 :            :                          */
    3159                 :         12 :                         dev->class = ehc->classes[dev->devno];
    3160                 :            : 
    3161         [ -  + ]:         12 :                         if (dev->class == ATA_DEV_PMP)
    3162                 :          0 :                                 rc = sata_pmp_attach(dev);
    3163                 :            :                         else
    3164                 :         12 :                                 rc = ata_dev_read_id(dev, &dev->class,
    3165                 :         12 :                                                      readid_flags, dev->id);
    3166                 :            : 
    3167                 :            :                         /* read_id might have changed class, store and reset */
    3168                 :         12 :                         ehc->classes[dev->devno] = dev->class;
    3169                 :         12 :                         dev->class = ATA_DEV_UNKNOWN;
    3170                 :            : 
    3171      [ +  +  - ]:         12 :                         switch (rc) {
    3172                 :          9 :                         case 0:
    3173                 :            :                                 /* clear error info accumulated during probe */
    3174                 :          9 :                                 ata_ering_clear(&dev->ering);
    3175                 :          9 :                                 new_mask |= 1 << dev->devno;
    3176                 :          9 :                                 break;
    3177                 :          3 :                         case -ENOENT:
    3178                 :            :                                 /* IDENTIFY was issued to non-existent
    3179                 :            :                                  * device.  No need to reset.  Just
    3180                 :            :                                  * thaw and ignore the device.
    3181                 :            :                                  */
    3182                 :          3 :                                 ata_eh_thaw_port(ap);
    3183                 :          3 :                                 break;
    3184                 :          0 :                         default:
    3185                 :          0 :                                 goto err;
    3186                 :            :                         }
    3187                 :         64 :                 }
    3188                 :            :         }
    3189                 :            : 
    3190                 :            :         /* PDIAG- should have been released, ask cable type if post-reset */
    3191   [ +  +  +  - ]:         44 :         if ((ehc->i.flags & ATA_EHI_DID_RESET) && ata_is_host_link(link)) {
    3192         [ +  - ]:          6 :                 if (ap->ops->cable_detect)
    3193                 :          6 :                         ap->cbl = ap->ops->cable_detect(ap);
    3194                 :          6 :                 ata_force_cbl(ap);
    3195                 :            :         }
    3196                 :            : 
    3197                 :            :         /* Configure new devices forward such that user doesn't see
    3198                 :            :          * device detection messages backwards.
    3199                 :            :          */
    3200         [ +  + ]:        114 :         ata_for_each_dev(dev, link, ALL) {
    3201         [ +  + ]:         76 :                 if (!(new_mask & (1 << dev->devno)))
    3202                 :         67 :                         continue;
    3203                 :            : 
    3204                 :          9 :                 dev->class = ehc->classes[dev->devno];
    3205                 :            : 
    3206         [ -  + ]:          9 :                 if (dev->class == ATA_DEV_PMP)
    3207                 :          0 :                         continue;
    3208                 :            : 
    3209                 :          9 :                 ehc->i.flags |= ATA_EHI_PRINTINFO;
    3210                 :          9 :                 rc = ata_dev_configure(dev);
    3211                 :          9 :                 ehc->i.flags &= ~ATA_EHI_PRINTINFO;
    3212         [ -  + ]:          9 :                 if (rc) {
    3213                 :          0 :                         dev->class = ATA_DEV_UNKNOWN;
    3214                 :          0 :                         goto err;
    3215                 :            :                 }
    3216                 :            : 
    3217                 :          9 :                 spin_lock_irqsave(ap->lock, flags);
    3218                 :          9 :                 ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG;
    3219                 :          9 :                 spin_unlock_irqrestore(ap->lock, flags);
    3220                 :            : 
    3221                 :            :                 /* new device discovered, configure xfermode */
    3222                 :          9 :                 ehc->i.flags |= ATA_EHI_SETMODE;
    3223                 :            :         }
    3224                 :            : 
    3225                 :            :         return 0;
    3226                 :            : 
    3227                 :          0 :  err:
    3228                 :          0 :         *r_failed_dev = dev;
    3229                 :          0 :         DPRINTK("EXIT rc=%d\n", rc);
    3230                 :          0 :         return rc;
    3231                 :            : }
    3232                 :            : 
    3233                 :            : /**
    3234                 :            :  *      ata_set_mode - Program timings and issue SET FEATURES - XFER
    3235                 :            :  *      @link: link on which timings will be programmed
    3236                 :            :  *      @r_failed_dev: out parameter for failed device
    3237                 :            :  *
    3238                 :            :  *      Set ATA device disk transfer mode (PIO3, UDMA6, etc.).  If
    3239                 :            :  *      ata_set_mode() fails, pointer to the failing device is
    3240                 :            :  *      returned in @r_failed_dev.
    3241                 :            :  *
    3242                 :            :  *      LOCKING:
    3243                 :            :  *      PCI/etc. bus probe sem.
    3244                 :            :  *
    3245                 :            :  *      RETURNS:
    3246                 :            :  *      0 on success, negative errno otherwise
    3247                 :            :  */
    3248                 :          6 : int ata_set_mode(struct ata_link *link, struct ata_device **r_failed_dev)
    3249                 :            : {
    3250                 :          6 :         struct ata_port *ap = link->ap;
    3251                 :          6 :         struct ata_device *dev;
    3252                 :          6 :         int rc;
    3253                 :            : 
    3254                 :            :         /* if data transfer is verified, clear DUBIOUS_XFER on ering top */
    3255         [ +  + ]:         15 :         ata_for_each_dev(dev, link, ENABLED) {
    3256         [ +  - ]:          9 :                 if (!(dev->flags & ATA_DFLAG_DUBIOUS_XFER)) {
    3257                 :          9 :                         struct ata_ering_entry *ent;
    3258                 :            : 
    3259         [ +  - ]:          9 :                         ent = ata_ering_top(&dev->ering);
    3260         [ +  - ]:          9 :                         if (ent)
    3261                 :          9 :                                 ent->eflags &= ~ATA_EFLAG_DUBIOUS_XFER;
    3262                 :            :                 }
    3263                 :            :         }
    3264                 :            : 
    3265                 :            :         /* has private set_mode? */
    3266         [ -  + ]:          6 :         if (ap->ops->set_mode)
    3267                 :          0 :                 rc = ap->ops->set_mode(link, r_failed_dev);
    3268                 :            :         else
    3269                 :          6 :                 rc = ata_do_set_mode(link, r_failed_dev);
    3270                 :            : 
    3271                 :            :         /* if transfer mode has changed, set DUBIOUS_XFER on device */
    3272         [ +  + ]:         15 :         ata_for_each_dev(dev, link, ENABLED) {
    3273                 :          9 :                 struct ata_eh_context *ehc = &link->eh_context;
    3274                 :          9 :                 u8 saved_xfer_mode = ehc->saved_xfer_mode[dev->devno];
    3275                 :          9 :                 u8 saved_ncq = !!(ehc->saved_ncq_enabled & (1 << dev->devno));
    3276                 :            : 
    3277   [ -  +  -  - ]:          9 :                 if (dev->xfer_mode != saved_xfer_mode ||
    3278         [ #  # ]:          0 :                     ata_ncq_enabled(dev) != saved_ncq)
    3279                 :          9 :                         dev->flags |= ATA_DFLAG_DUBIOUS_XFER;
    3280                 :            :         }
    3281                 :            : 
    3282                 :          6 :         return rc;
    3283                 :            : }
    3284                 :            : 
    3285                 :            : /**
    3286                 :            :  *      atapi_eh_clear_ua - Clear ATAPI UNIT ATTENTION after reset
    3287                 :            :  *      @dev: ATAPI device to clear UA for
    3288                 :            :  *
    3289                 :            :  *      Resets and other operations can make an ATAPI device raise
    3290                 :            :  *      UNIT ATTENTION which causes the next operation to fail.  This
    3291                 :            :  *      function clears UA.
    3292                 :            :  *
    3293                 :            :  *      LOCKING:
    3294                 :            :  *      EH context (may sleep).
    3295                 :            :  *
    3296                 :            :  *      RETURNS:
    3297                 :            :  *      0 on success, -errno on failure.
    3298                 :            :  */
    3299                 :          3 : static int atapi_eh_clear_ua(struct ata_device *dev)
    3300                 :            : {
    3301                 :          3 :         int i;
    3302                 :            : 
    3303         [ +  - ]:          3 :         for (i = 0; i < ATA_EH_UA_TRIES; i++) {
    3304                 :          3 :                 u8 *sense_buffer = dev->link->ap->sector_buf;
    3305                 :          3 :                 u8 sense_key = 0;
    3306                 :          3 :                 unsigned int err_mask;
    3307                 :            : 
    3308                 :          3 :                 err_mask = atapi_eh_tur(dev, &sense_key);
    3309         [ -  + ]:          3 :                 if (err_mask != 0 && err_mask != AC_ERR_DEV) {
    3310                 :          0 :                         ata_dev_warn(dev,
    3311                 :            :                                      "TEST_UNIT_READY failed (err_mask=0x%x)\n",
    3312                 :            :                                      err_mask);
    3313                 :          3 :                         return -EIO;
    3314                 :            :                 }
    3315                 :            : 
    3316   [ +  -  -  + ]:          3 :                 if (!err_mask || sense_key != UNIT_ATTENTION)
    3317                 :            :                         return 0;
    3318                 :            : 
    3319                 :          0 :                 err_mask = atapi_eh_request_sense(dev, sense_buffer, sense_key);
    3320         [ #  # ]:          0 :                 if (err_mask) {
    3321                 :          0 :                         ata_dev_warn(dev, "failed to clear "
    3322                 :            :                                 "UNIT ATTENTION (err_mask=0x%x)\n", err_mask);
    3323                 :          0 :                         return -EIO;
    3324                 :            :                 }
    3325                 :            :         }
    3326                 :            : 
    3327                 :          0 :         ata_dev_warn(dev, "UNIT ATTENTION persists after %d tries\n",
    3328                 :            :                      ATA_EH_UA_TRIES);
    3329                 :            : 
    3330                 :          0 :         return 0;
    3331                 :            : }
    3332                 :            : 
    3333                 :            : /**
    3334                 :            :  *      ata_eh_maybe_retry_flush - Retry FLUSH if necessary
    3335                 :            :  *      @dev: ATA device which may need FLUSH retry
    3336                 :            :  *
    3337                 :            :  *      If @dev failed FLUSH, it needs to be reported upper layer
    3338                 :            :  *      immediately as it means that @dev failed to remap and already
    3339                 :            :  *      lost at least a sector and further FLUSH retrials won't make
    3340                 :            :  *      any difference to the lost sector.  However, if FLUSH failed
    3341                 :            :  *      for other reasons, for example transmission error, FLUSH needs
    3342                 :            :  *      to be retried.
    3343                 :            :  *
    3344                 :            :  *      This function determines whether FLUSH failure retry is
    3345                 :            :  *      necessary and performs it if so.
    3346                 :            :  *
    3347                 :            :  *      RETURNS:
    3348                 :            :  *      0 if EH can continue, -errno if EH needs to be repeated.
    3349                 :            :  */
    3350                 :          6 : static int ata_eh_maybe_retry_flush(struct ata_device *dev)
    3351                 :            : {
    3352                 :          6 :         struct ata_link *link = dev->link;
    3353                 :          6 :         struct ata_port *ap = link->ap;
    3354                 :          6 :         struct ata_queued_cmd *qc;
    3355                 :          6 :         struct ata_taskfile tf;
    3356                 :          6 :         unsigned int err_mask;
    3357                 :          6 :         int rc = 0;
    3358                 :            : 
    3359                 :            :         /* did flush fail for this device? */
    3360   [ +  -  -  + ]:         12 :         if (!ata_tag_valid(link->active_tag))
    3361                 :            :                 return 0;
    3362                 :            : 
    3363         [ #  # ]:          0 :         qc = __ata_qc_from_tag(ap, link->active_tag);
    3364   [ #  #  #  # ]:          0 :         if (qc->dev != dev || (qc->tf.command != ATA_CMD_FLUSH_EXT &&
    3365                 :            :                                qc->tf.command != ATA_CMD_FLUSH))
    3366                 :            :                 return 0;
    3367                 :            : 
    3368                 :            :         /* if the device failed it, it should be reported to upper layers */
    3369         [ #  # ]:          0 :         if (qc->err_mask & AC_ERR_DEV)
    3370                 :            :                 return 0;
    3371                 :            : 
    3372                 :            :         /* flush failed for some other reason, give it another shot */
    3373         [ #  # ]:          0 :         ata_tf_init(dev, &tf);
    3374                 :            : 
    3375                 :          0 :         tf.command = qc->tf.command;
    3376                 :          0 :         tf.flags |= ATA_TFLAG_DEVICE;
    3377                 :          0 :         tf.protocol = ATA_PROT_NODATA;
    3378                 :            : 
    3379                 :          0 :         ata_dev_warn(dev, "retrying FLUSH 0x%x Emask 0x%x\n",
    3380                 :            :                        tf.command, qc->err_mask);
    3381                 :            : 
    3382                 :          0 :         err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
    3383         [ #  # ]:          0 :         if (!err_mask) {
    3384                 :            :                 /*
    3385                 :            :                  * FLUSH is complete but there's no way to
    3386                 :            :                  * successfully complete a failed command from EH.
    3387                 :            :                  * Making sure retry is allowed at least once and
    3388                 :            :                  * retrying it should do the trick - whatever was in
    3389                 :            :                  * the cache is already on the platter and this won't
    3390                 :            :                  * cause infinite loop.
    3391                 :            :                  */
    3392                 :          0 :                 qc->scsicmd->allowed = max(qc->scsicmd->allowed, 1);
    3393                 :            :         } else {
    3394                 :          0 :                 ata_dev_warn(dev, "FLUSH failed Emask 0x%x\n",
    3395                 :            :                                err_mask);
    3396                 :          0 :                 rc = -EIO;
    3397                 :            : 
    3398                 :            :                 /* if device failed it, report it to upper layers */
    3399         [ #  # ]:          0 :                 if (err_mask & AC_ERR_DEV) {
    3400                 :          0 :                         qc->err_mask |= AC_ERR_DEV;
    3401                 :          0 :                         qc->result_tf = tf;
    3402         [ #  # ]:          0 :                         if (!(ap->pflags & ATA_PFLAG_FROZEN))
    3403                 :          0 :                                 rc = 0;
    3404                 :            :                 }
    3405                 :            :         }
    3406                 :            :         return rc;
    3407                 :            : }
    3408                 :            : 
    3409                 :            : /**
    3410                 :            :  *      ata_eh_set_lpm - configure SATA interface power management
    3411                 :            :  *      @link: link to configure power management
    3412                 :            :  *      @policy: the link power management policy
    3413                 :            :  *      @r_failed_dev: out parameter for failed device
    3414                 :            :  *
    3415                 :            :  *      Enable SATA Interface power management.  This will enable
    3416                 :            :  *      Device Interface Power Management (DIPM) for min_power and
    3417                 :            :  *      medium_power_with_dipm policies, and then call driver specific
    3418                 :            :  *      callbacks for enabling Host Initiated Power management.
    3419                 :            :  *
    3420                 :            :  *      LOCKING:
    3421                 :            :  *      EH context.
    3422                 :            :  *
    3423                 :            :  *      RETURNS:
    3424                 :            :  *      0 on success, -errno on failure.
    3425                 :            :  */
    3426                 :          0 : static int ata_eh_set_lpm(struct ata_link *link, enum ata_lpm_policy policy,
    3427                 :            :                           struct ata_device **r_failed_dev)
    3428                 :            : {
    3429   [ #  #  #  # ]:          0 :         struct ata_port *ap = ata_is_host_link(link) ? link->ap : NULL;
    3430                 :          0 :         struct ata_eh_context *ehc = &link->eh_context;
    3431                 :          0 :         struct ata_device *dev, *link_dev = NULL, *lpm_dev = NULL;
    3432                 :          0 :         enum ata_lpm_policy old_policy = link->lpm_policy;
    3433                 :          0 :         bool no_dipm = link->ap->flags & ATA_FLAG_NO_DIPM;
    3434                 :          0 :         unsigned int hints = ATA_LPM_EMPTY | ATA_LPM_HIPM;
    3435                 :          0 :         unsigned int err_mask;
    3436                 :          0 :         int rc;
    3437                 :            : 
    3438                 :            :         /* if the link or host doesn't do LPM, noop */
    3439   [ #  #  #  #  :          0 :         if ((link->flags & ATA_LFLAG_NO_LPM) || (ap && !ap->ops->set_lpm))
                   #  # ]
    3440                 :            :                 return 0;
    3441                 :            : 
    3442                 :            :         /*
    3443                 :            :          * DIPM is enabled only for MIN_POWER as some devices
    3444                 :            :          * misbehave when the host NACKs transition to SLUMBER.  Order
    3445                 :            :          * device and link configurations such that the host always
    3446                 :            :          * allows DIPM requests.
    3447                 :            :          */
    3448         [ #  # ]:          0 :         ata_for_each_dev(dev, link, ENABLED) {
    3449         [ #  # ]:          0 :                 bool hipm = ata_id_has_hipm(dev->id);
    3450   [ #  #  #  #  :          0 :                 bool dipm = ata_id_has_dipm(dev->id) && !no_dipm;
                   #  # ]
    3451                 :            : 
    3452                 :            :                 /* find the first enabled and LPM enabled devices */
    3453         [ #  # ]:          0 :                 if (!link_dev)
    3454                 :          0 :                         link_dev = dev;
    3455                 :            : 
    3456   [ #  #  #  # ]:          0 :                 if (!lpm_dev && (hipm || dipm))
    3457                 :          0 :                         lpm_dev = dev;
    3458                 :            : 
    3459                 :          0 :                 hints &= ~ATA_LPM_EMPTY;
    3460         [ #  # ]:          0 :                 if (!hipm)
    3461                 :          0 :                         hints &= ~ATA_LPM_HIPM;
    3462                 :            : 
    3463                 :            :                 /* disable DIPM before changing link config */
    3464         [ #  # ]:          0 :                 if (policy < ATA_LPM_MED_POWER_WITH_DIPM && dipm) {
    3465                 :          0 :                         err_mask = ata_dev_set_feature(dev,
    3466                 :            :                                         SETFEATURES_SATA_DISABLE, SATA_DIPM);
    3467         [ #  # ]:          0 :                         if (err_mask && err_mask != AC_ERR_DEV) {
    3468                 :          0 :                                 ata_dev_warn(dev,
    3469                 :            :                                              "failed to disable DIPM, Emask 0x%x\n",
    3470                 :            :                                              err_mask);
    3471                 :          0 :                                 rc = -EIO;
    3472                 :          0 :                                 goto fail;
    3473                 :            :                         }
    3474                 :            :                 }
    3475                 :            :         }
    3476                 :            : 
    3477         [ #  # ]:          0 :         if (ap) {
    3478                 :          0 :                 rc = ap->ops->set_lpm(link, policy, hints);
    3479   [ #  #  #  # ]:          0 :                 if (!rc && ap->slave_link)
    3480                 :          0 :                         rc = ap->ops->set_lpm(ap->slave_link, policy, hints);
    3481                 :            :         } else
    3482                 :          0 :                 rc = sata_pmp_set_lpm(link, policy, hints);
    3483                 :            : 
    3484                 :            :         /*
    3485                 :            :          * Attribute link config failure to the first (LPM) enabled
    3486                 :            :          * device on the link.
    3487                 :            :          */
    3488         [ #  # ]:          0 :         if (rc) {
    3489         [ #  # ]:          0 :                 if (rc == -EOPNOTSUPP) {
    3490                 :          0 :                         link->flags |= ATA_LFLAG_NO_LPM;
    3491                 :          0 :                         return 0;
    3492                 :            :                 }
    3493         [ #  # ]:          0 :                 dev = lpm_dev ? lpm_dev : link_dev;
    3494                 :          0 :                 goto fail;
    3495                 :            :         }
    3496                 :            : 
    3497                 :            :         /*
    3498                 :            :          * Low level driver acked the transition.  Issue DIPM command
    3499                 :            :          * with the new policy set.
    3500                 :            :          */
    3501                 :          0 :         link->lpm_policy = policy;
    3502   [ #  #  #  # ]:          0 :         if (ap && ap->slave_link)
    3503                 :          0 :                 ap->slave_link->lpm_policy = policy;
    3504                 :            : 
    3505                 :            :         /* host config updated, enable DIPM if transitioning to MIN_POWER */
    3506         [ #  # ]:          0 :         ata_for_each_dev(dev, link, ENABLED) {
    3507   [ #  #  #  # ]:          0 :                 if (policy >= ATA_LPM_MED_POWER_WITH_DIPM && !no_dipm &&
    3508                 :            :                     ata_id_has_dipm(dev->id)) {
    3509                 :          0 :                         err_mask = ata_dev_set_feature(dev,
    3510                 :            :                                         SETFEATURES_SATA_ENABLE, SATA_DIPM);
    3511         [ #  # ]:          0 :                         if (err_mask && err_mask != AC_ERR_DEV) {
    3512                 :          0 :                                 ata_dev_warn(dev,
    3513                 :            :                                         "failed to enable DIPM, Emask 0x%x\n",
    3514                 :            :                                         err_mask);
    3515                 :          0 :                                 rc = -EIO;
    3516                 :          0 :                                 goto fail;
    3517                 :            :                         }
    3518                 :            :                 }
    3519                 :            :         }
    3520                 :            : 
    3521                 :          0 :         link->last_lpm_change = jiffies;
    3522                 :          0 :         link->flags |= ATA_LFLAG_CHANGED;
    3523                 :            : 
    3524                 :          0 :         return 0;
    3525                 :            : 
    3526                 :          0 : fail:
    3527                 :            :         /* restore the old policy */
    3528                 :          0 :         link->lpm_policy = old_policy;
    3529   [ #  #  #  # ]:          0 :         if (ap && ap->slave_link)
    3530                 :          0 :                 ap->slave_link->lpm_policy = old_policy;
    3531                 :            : 
    3532                 :            :         /* if no device or only one more chance is left, disable LPM */
    3533   [ #  #  #  # ]:          0 :         if (!dev || ehc->tries[dev->devno] <= 2) {
    3534                 :          0 :                 ata_link_warn(link, "disabling LPM on the link\n");
    3535                 :          0 :                 link->flags |= ATA_LFLAG_NO_LPM;
    3536                 :            :         }
    3537         [ #  # ]:          0 :         if (r_failed_dev)
    3538                 :          0 :                 *r_failed_dev = dev;
    3539                 :            :         return rc;
    3540                 :            : }
    3541                 :            : 
    3542                 :         32 : int ata_link_nr_enabled(struct ata_link *link)
    3543                 :            : {
    3544                 :         32 :         struct ata_device *dev;
    3545                 :         32 :         int cnt = 0;
    3546                 :            : 
    3547         [ +  + ]:         64 :         ata_for_each_dev(dev, link, ENABLED)
    3548                 :         32 :                 cnt++;
    3549                 :         32 :         return cnt;
    3550                 :            : }
    3551                 :            : 
    3552                 :          6 : static int ata_link_nr_vacant(struct ata_link *link)
    3553                 :            : {
    3554                 :          6 :         struct ata_device *dev;
    3555                 :          6 :         int cnt = 0;
    3556                 :            : 
    3557         [ +  + ]:         18 :         ata_for_each_dev(dev, link, ALL)
    3558         [ +  - ]:         12 :                 if (dev->class == ATA_DEV_UNKNOWN)
    3559                 :         12 :                         cnt++;
    3560                 :          6 :         return cnt;
    3561                 :            : }
    3562                 :            : 
    3563                 :         38 : static int ata_eh_skip_recovery(struct ata_link *link)
    3564                 :            : {
    3565                 :         38 :         struct ata_port *ap = link->ap;
    3566                 :         38 :         struct ata_eh_context *ehc = &link->eh_context;
    3567                 :         38 :         struct ata_device *dev;
    3568                 :            : 
    3569                 :            :         /* skip disabled links */
    3570         [ +  - ]:         38 :         if (link->flags & ATA_LFLAG_DISABLED)
    3571                 :            :                 return 1;
    3572                 :            : 
    3573                 :            :         /* skip if explicitly requested */
    3574         [ +  - ]:         38 :         if (ehc->i.flags & ATA_EHI_NO_RECOVERY)
    3575                 :            :                 return 1;
    3576                 :            : 
    3577                 :            :         /* thaw frozen port and recover failed devices */
    3578   [ +  +  +  - ]:         38 :         if ((ap->pflags & ATA_PFLAG_FROZEN) || ata_link_nr_enabled(link))
    3579                 :         38 :                 return 0;
    3580                 :            : 
    3581                 :            :         /* reset at least once if reset is requested */
    3582         [ #  # ]:          0 :         if ((ehc->i.action & ATA_EH_RESET) &&
    3583         [ #  # ]:          0 :             !(ehc->i.flags & ATA_EHI_DID_RESET))
    3584                 :            :                 return 0;
    3585                 :            : 
    3586                 :            :         /* skip if class codes for all vacant slots are ATA_DEV_NONE */
    3587         [ #  # ]:          0 :         ata_for_each_dev(dev, link, ALL) {
    3588         [ #  # ]:          0 :                 if (dev->class == ATA_DEV_UNKNOWN &&
    3589         [ #  # ]:          0 :                     ehc->classes[dev->devno] != ATA_DEV_NONE)
    3590                 :            :                         return 0;
    3591                 :            :         }
    3592                 :            : 
    3593                 :            :         return 1;
    3594                 :            : }
    3595                 :            : 
    3596                 :         12 : static int ata_count_probe_trials_cb(struct ata_ering_entry *ent, void *void_arg)
    3597                 :            : {
    3598         [ +  - ]:         12 :         u64 interval = msecs_to_jiffies(ATA_EH_PROBE_TRIAL_INTERVAL);
    3599         [ +  - ]:         12 :         u64 now = get_jiffies_64();
    3600                 :         12 :         int *trials = void_arg;
    3601                 :            : 
    3602         [ +  - ]:         12 :         if ((ent->eflags & ATA_EFLAG_OLD_ER) ||
    3603         [ +  - ]:         12 :             (ent->timestamp < now - min(now, interval)))
    3604                 :            :                 return -1;
    3605                 :            : 
    3606                 :         12 :         (*trials)++;
    3607                 :         12 :         return 0;
    3608                 :            : }
    3609                 :            : 
    3610                 :         44 : static int ata_eh_schedule_probe(struct ata_device *dev)
    3611                 :            : {
    3612                 :         44 :         struct ata_eh_context *ehc = &dev->link->eh_context;
    3613                 :         44 :         struct ata_link *link = ata_dev_phys_link(dev);
    3614                 :         44 :         int trials = 0;
    3615                 :            : 
    3616         [ +  + ]:         44 :         if (!(ehc->i.probe_mask & (1 << dev->devno)) ||
    3617         [ +  - ]:         12 :             (ehc->did_probe_mask & (1 << dev->devno)))
    3618                 :            :                 return 0;
    3619                 :            : 
    3620                 :         12 :         ata_eh_detach_dev(dev);
    3621                 :         12 :         ata_dev_init(dev);
    3622                 :         12 :         ehc->did_probe_mask |= (1 << dev->devno);
    3623                 :         12 :         ehc->i.action |= ATA_EH_RESET;
    3624                 :         12 :         ehc->saved_xfer_mode[dev->devno] = 0;
    3625                 :         12 :         ehc->saved_ncq_enabled &= ~(1 << dev->devno);
    3626                 :            : 
    3627                 :            :         /* the link maybe in a deep sleep, wake it up */
    3628         [ -  + ]:         12 :         if (link->lpm_policy > ATA_LPM_MAX_POWER) {
    3629   [ #  #  #  # ]:          0 :                 if (ata_is_host_link(link))
    3630                 :          0 :                         link->ap->ops->set_lpm(link, ATA_LPM_MAX_POWER,
    3631                 :            :                                                ATA_LPM_EMPTY);
    3632                 :            :                 else
    3633                 :          0 :                         sata_pmp_set_lpm(link, ATA_LPM_MAX_POWER,
    3634                 :            :                                          ATA_LPM_EMPTY);
    3635                 :            :         }
    3636                 :            : 
    3637                 :            :         /* Record and count probe trials on the ering.  The specific
    3638                 :            :          * error mask used is irrelevant.  Because a successful device
    3639                 :            :          * detection clears the ering, this count accumulates only if
    3640                 :            :          * there are consecutive failed probes.
    3641                 :            :          *
    3642                 :            :          * If the count is equal to or higher than ATA_EH_PROBE_TRIALS
    3643                 :            :          * in the last ATA_EH_PROBE_TRIAL_INTERVAL, link speed is
    3644                 :            :          * forced to 1.5Gbps.
    3645                 :            :          *
    3646                 :            :          * This is to work around cases where failed link speed
    3647                 :            :          * negotiation results in device misdetection leading to
    3648                 :            :          * infinite DEVXCHG or PHRDY CHG events.
    3649                 :            :          */
    3650                 :         12 :         ata_ering_record(&dev->ering, 0, AC_ERR_OTHER);
    3651                 :         12 :         ata_ering_map(&dev->ering, ata_count_probe_trials_cb, &trials);
    3652                 :            : 
    3653         [ -  + ]:         12 :         if (trials > ATA_EH_PROBE_TRIALS)
    3654                 :          0 :                 sata_down_spd_limit(link, 1);
    3655                 :            : 
    3656                 :            :         return 1;
    3657                 :            : }
    3658                 :            : 
    3659                 :          0 : static int ata_eh_handle_dev_fail(struct ata_device *dev, int err)
    3660                 :            : {
    3661                 :          0 :         struct ata_eh_context *ehc = &dev->link->eh_context;
    3662                 :            : 
    3663                 :            :         /* -EAGAIN from EH routine indicates retry without prejudice.
    3664                 :            :          * The requester is responsible for ensuring forward progress.
    3665                 :            :          */
    3666         [ #  # ]:          0 :         if (err != -EAGAIN)
    3667                 :          0 :                 ehc->tries[dev->devno]--;
    3668                 :            : 
    3669   [ #  #  #  # ]:          0 :         switch (err) {
    3670                 :          0 :         case -ENODEV:
    3671                 :            :                 /* device missing or wrong IDENTIFY data, schedule probing */
    3672                 :          0 :                 ehc->i.probe_mask |= (1 << dev->devno);
    3673                 :            :                 /* fall through */
    3674                 :          0 :         case -EINVAL:
    3675                 :            :                 /* give it just one more chance */
    3676                 :          0 :                 ehc->tries[dev->devno] = min(ehc->tries[dev->devno], 1);
    3677                 :            :                 /* fall through */
    3678                 :          0 :         case -EIO:
    3679         [ #  # ]:          0 :                 if (ehc->tries[dev->devno] == 1) {
    3680                 :            :                         /* This is the last chance, better to slow
    3681                 :            :                          * down than lose it.
    3682                 :            :                          */
    3683                 :          0 :                         sata_down_spd_limit(ata_dev_phys_link(dev), 0);
    3684         [ #  # ]:          0 :                         if (dev->pio_mode > XFER_PIO_0)
    3685                 :          0 :                                 ata_down_xfermask_limit(dev, ATA_DNXFER_PIO);
    3686                 :            :                 }
    3687                 :            :         }
    3688                 :            : 
    3689   [ #  #  #  #  :          0 :         if (ata_dev_enabled(dev) && !ehc->tries[dev->devno]) {
                   #  # ]
    3690                 :            :                 /* disable device if it has used up all its chances */
    3691                 :          0 :                 ata_dev_disable(dev);
    3692                 :            : 
    3693                 :            :                 /* detach if offline */
    3694         [ #  # ]:          0 :                 if (ata_phys_link_offline(ata_dev_phys_link(dev)))
    3695                 :          0 :                         ata_eh_detach_dev(dev);
    3696                 :            : 
    3697                 :            :                 /* schedule probe if necessary */
    3698         [ #  # ]:          0 :                 if (ata_eh_schedule_probe(dev)) {
    3699                 :          0 :                         ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
    3700                 :          0 :                         memset(ehc->cmd_timeout_idx[dev->devno], 0,
    3701                 :            :                                sizeof(ehc->cmd_timeout_idx[dev->devno]));
    3702                 :            :                 }
    3703                 :            : 
    3704                 :          0 :                 return 1;
    3705                 :            :         } else {
    3706                 :          0 :                 ehc->i.action |= ATA_EH_RESET;
    3707                 :          0 :                 return 0;
    3708                 :            :         }
    3709                 :            : }
    3710                 :            : 
    3711                 :            : /**
    3712                 :            :  *      ata_eh_recover - recover host port after error
    3713                 :            :  *      @ap: host port to recover
    3714                 :            :  *      @prereset: prereset method (can be NULL)
    3715                 :            :  *      @softreset: softreset method (can be NULL)
    3716                 :            :  *      @hardreset: hardreset method (can be NULL)
    3717                 :            :  *      @postreset: postreset method (can be NULL)
    3718                 :            :  *      @r_failed_link: out parameter for failed link
    3719                 :            :  *
    3720                 :            :  *      This is the alpha and omega, eum and yang, heart and soul of
    3721                 :            :  *      libata exception handling.  On entry, actions required to
    3722                 :            :  *      recover each link and hotplug requests are recorded in the
    3723                 :            :  *      link's eh_context.  This function executes all the operations
    3724                 :            :  *      with appropriate retrials and fallbacks to resurrect failed
    3725                 :            :  *      devices, detach goners and greet newcomers.
    3726                 :            :  *
    3727                 :            :  *      LOCKING:
    3728                 :            :  *      Kernel thread context (may sleep).
    3729                 :            :  *
    3730                 :            :  *      RETURNS:
    3731                 :            :  *      0 on success, -errno on failure.
    3732                 :            :  */
    3733                 :         38 : int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
    3734                 :            :                    ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
    3735                 :            :                    ata_postreset_fn_t postreset,
    3736                 :            :                    struct ata_link **r_failed_link)
    3737                 :            : {
    3738                 :         38 :         struct ata_link *link;
    3739                 :         38 :         struct ata_device *dev;
    3740                 :         38 :         int rc, nr_fails;
    3741                 :         38 :         unsigned long flags, deadline;
    3742                 :            : 
    3743                 :         38 :         DPRINTK("ENTER\n");
    3744                 :            : 
    3745                 :            :         /* prep for recovery */
    3746         [ +  + ]:         76 :         ata_for_each_link(link, ap, EDGE) {
    3747                 :         38 :                 struct ata_eh_context *ehc = &link->eh_context;
    3748                 :            : 
    3749                 :            :                 /* re-enable link? */
    3750         [ -  + ]:         38 :                 if (ehc->i.action & ATA_EH_ENABLE_LINK) {
    3751                 :          0 :                         ata_eh_about_to_do(link, NULL, ATA_EH_ENABLE_LINK);
    3752                 :          0 :                         spin_lock_irqsave(ap->lock, flags);
    3753                 :          0 :                         link->flags &= ~ATA_LFLAG_DISABLED;
    3754                 :          0 :                         spin_unlock_irqrestore(ap->lock, flags);
    3755                 :          0 :                         ata_eh_done(link, NULL, ATA_EH_ENABLE_LINK);
    3756                 :            :                 }
    3757                 :            : 
    3758         [ +  + ]:        114 :                 ata_for_each_dev(dev, link, ALL) {
    3759         [ -  + ]:         76 :                         if (link->flags & ATA_LFLAG_NO_RETRY)
    3760                 :          0 :                                 ehc->tries[dev->devno] = 1;
    3761                 :            :                         else
    3762                 :         76 :                                 ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
    3763                 :            : 
    3764                 :            :                         /* collect port action mask recorded in dev actions */
    3765                 :         76 :                         ehc->i.action |= ehc->i.dev_action[dev->devno] &
    3766                 :            :                                          ~ATA_EH_PERDEV_MASK;
    3767                 :         76 :                         ehc->i.dev_action[dev->devno] &= ATA_EH_PERDEV_MASK;
    3768                 :            : 
    3769                 :            :                         /* process hotplug request */
    3770         [ -  + ]:         76 :                         if (dev->flags & ATA_DFLAG_DETACH)
    3771                 :          0 :                                 ata_eh_detach_dev(dev);
    3772                 :            : 
    3773                 :            :                         /* schedule probe if necessary */
    3774   [ +  +  +  + ]:        120 :                         if (!ata_dev_enabled(dev))
    3775                 :         44 :                                 ata_eh_schedule_probe(dev);
    3776                 :            :                 }
    3777                 :            :         }
    3778                 :            : 
    3779                 :         38 :  retry:
    3780                 :         38 :         rc = 0;
    3781                 :            : 
    3782                 :            :         /* if UNLOADING, finish immediately */
    3783         [ -  + ]:         38 :         if (ap->pflags & ATA_PFLAG_UNLOADING)
    3784                 :          0 :                 goto out;
    3785                 :            : 
    3786                 :            :         /* prep for EH */
    3787         [ +  + ]:         76 :         ata_for_each_link(link, ap, EDGE) {
    3788                 :         38 :                 struct ata_eh_context *ehc = &link->eh_context;
    3789                 :            : 
    3790                 :            :                 /* skip EH if possible. */
    3791         [ -  + ]:         38 :                 if (ata_eh_skip_recovery(link))
    3792                 :          0 :                         ehc->i.action = 0;
    3793                 :            : 
    3794         [ +  + ]:        114 :                 ata_for_each_dev(dev, link, ALL)
    3795                 :         76 :                         ehc->classes[dev->devno] = ATA_DEV_UNKNOWN;
    3796                 :            :         }
    3797                 :            : 
    3798                 :            :         /* reset */
    3799         [ +  + ]:         76 :         ata_for_each_link(link, ap, EDGE) {
    3800                 :         38 :                 struct ata_eh_context *ehc = &link->eh_context;
    3801                 :            : 
    3802         [ +  + ]:         38 :                 if (!(ehc->i.action & ATA_EH_RESET))
    3803                 :         32 :                         continue;
    3804                 :            : 
    3805                 :          6 :                 rc = ata_eh_reset(link, ata_link_nr_vacant(link),
    3806                 :            :                                   prereset, softreset, hardreset, postreset);
    3807         [ -  + ]:          6 :                 if (rc) {
    3808                 :          0 :                         ata_link_err(link, "reset failed, giving up\n");
    3809                 :          0 :                         goto out;
    3810                 :            :                 }
    3811                 :            :         }
    3812                 :            : 
    3813                 :         38 :         do {
    3814                 :         38 :                 unsigned long now;
    3815                 :            : 
    3816                 :            :                 /*
    3817                 :            :                  * clears ATA_EH_PARK in eh_info and resets
    3818                 :            :                  * ap->park_req_pending
    3819                 :            :                  */
    3820                 :         38 :                 ata_eh_pull_park_action(ap);
    3821                 :            : 
    3822                 :         38 :                 deadline = jiffies;
    3823         [ +  + ]:         76 :                 ata_for_each_link(link, ap, EDGE) {
    3824         [ +  + ]:        114 :                         ata_for_each_dev(dev, link, ALL) {
    3825                 :         76 :                                 struct ata_eh_context *ehc = &link->eh_context;
    3826                 :         76 :                                 unsigned long tmp;
    3827                 :            : 
    3828         [ +  - ]:         76 :                                 if (dev->class != ATA_DEV_ATA &&
    3829                 :            :                                     dev->class != ATA_DEV_ZAC)
    3830                 :         76 :                                         continue;
    3831         [ #  # ]:          0 :                                 if (!(ehc->i.dev_action[dev->devno] &
    3832                 :            :                                       ATA_EH_PARK))
    3833                 :          0 :                                         continue;
    3834                 :          0 :                                 tmp = dev->unpark_deadline;
    3835         [ #  # ]:          0 :                                 if (time_before(deadline, tmp))
    3836                 :            :                                         deadline = tmp;
    3837         [ #  # ]:          0 :                                 else if (time_before_eq(tmp, jiffies))
    3838                 :          0 :                                         continue;
    3839         [ #  # ]:          0 :                                 if (ehc->unloaded_mask & (1 << dev->devno))
    3840                 :          0 :                                         continue;
    3841                 :            : 
    3842                 :          0 :                                 ata_eh_park_issue_cmd(dev, 1);
    3843                 :            :                         }
    3844                 :            :                 }
    3845                 :            : 
    3846                 :         38 :                 now = jiffies;
    3847         [ -  + ]:         38 :                 if (time_before_eq(deadline, now))
    3848                 :            :                         break;
    3849                 :            : 
    3850                 :          0 :                 ata_eh_release(ap);
    3851                 :          0 :                 deadline = wait_for_completion_timeout(&ap->park_req_pending,
    3852                 :            :                                                        deadline - now);
    3853                 :          0 :                 ata_eh_acquire(ap);
    3854         [ #  # ]:          0 :         } while (deadline);
    3855         [ +  + ]:         76 :         ata_for_each_link(link, ap, EDGE) {
    3856         [ +  + ]:        114 :                 ata_for_each_dev(dev, link, ALL) {
    3857                 :         76 :                         if (!(link->eh_context.unloaded_mask &
    3858         [ +  - ]:         76 :                               (1 << dev->devno)))
    3859                 :         76 :                                 continue;
    3860                 :            : 
    3861                 :          0 :                         ata_eh_park_issue_cmd(dev, 0);
    3862                 :          0 :                         ata_eh_done(link, dev, ATA_EH_PARK);
    3863                 :            :                 }
    3864                 :            :         }
    3865                 :            : 
    3866                 :            :         /* the rest */
    3867                 :         38 :         nr_fails = 0;
    3868         [ +  + ]:         76 :         ata_for_each_link(link, ap, PMP_FIRST) {
    3869                 :         38 :                 struct ata_eh_context *ehc = &link->eh_context;
    3870                 :            : 
    3871   [ -  +  -  - ]:         38 :                 if (sata_pmp_attached(ap) && ata_is_host_link(link))
    3872                 :          0 :                         goto config_lpm;
    3873                 :            : 
    3874                 :            :                 /* revalidate existing devices and attach new ones */
    3875                 :         38 :                 rc = ata_eh_revalidate_and_attach(link, &dev);
    3876         [ -  + ]:         38 :                 if (rc)
    3877                 :          0 :                         goto rest_fail;
    3878                 :            : 
    3879                 :            :                 /* if PMP got attached, return, pmp EH will take care of it */
    3880         [ -  + ]:         38 :                 if (link->device->class == ATA_DEV_PMP) {
    3881                 :          0 :                         ehc->i.action = 0;
    3882                 :          0 :                         return 0;
    3883                 :            :                 }
    3884                 :            : 
    3885                 :            :                 /* configure transfer mode if necessary */
    3886         [ +  + ]:         38 :                 if (ehc->i.flags & ATA_EHI_SETMODE) {
    3887                 :          6 :                         rc = ata_set_mode(link, &dev);
    3888         [ -  + ]:          6 :                         if (rc)
    3889                 :          0 :                                 goto rest_fail;
    3890                 :          6 :                         ehc->i.flags &= ~ATA_EHI_SETMODE;
    3891                 :            :                 }
    3892                 :            : 
    3893                 :            :                 /* If reset has been issued, clear UA to avoid
    3894                 :            :                  * disrupting the current users of the device.
    3895                 :            :                  */
    3896         [ +  + ]:         38 :                 if (ehc->i.flags & ATA_EHI_DID_RESET) {
    3897         [ +  + ]:         18 :                         ata_for_each_dev(dev, link, ALL) {
    3898         [ +  + ]:         12 :                                 if (dev->class != ATA_DEV_ATAPI)
    3899                 :          9 :                                         continue;
    3900                 :          3 :                                 rc = atapi_eh_clear_ua(dev);
    3901         [ -  + ]:          3 :                                 if (rc)
    3902                 :          0 :                                         goto rest_fail;
    3903                 :            :                                 if (zpodd_dev_enabled(dev))
    3904                 :            :                                         zpodd_post_poweron(dev);
    3905                 :            :                         }
    3906                 :            :                 }
    3907                 :            : 
    3908                 :            :                 /* retry flush if necessary */
    3909         [ +  + ]:        114 :                 ata_for_each_dev(dev, link, ALL) {
    3910         [ +  + ]:         76 :                         if (dev->class != ATA_DEV_ATA &&
    3911                 :            :                             dev->class != ATA_DEV_ZAC)
    3912                 :         70 :                                 continue;
    3913                 :          6 :                         rc = ata_eh_maybe_retry_flush(dev);
    3914         [ -  + ]:          6 :                         if (rc)
    3915                 :          0 :                                 goto rest_fail;
    3916                 :            :                 }
    3917                 :            : 
    3918                 :         38 :         config_lpm:
    3919                 :            :                 /* configure link power saving */
    3920         [ -  + ]:         38 :                 if (link->lpm_policy != ap->target_lpm_policy) {
    3921                 :          0 :                         rc = ata_eh_set_lpm(link, ap->target_lpm_policy, &dev);
    3922         [ #  # ]:          0 :                         if (rc)
    3923                 :          0 :                                 goto rest_fail;
    3924                 :            :                 }
    3925                 :            : 
    3926                 :            :                 /* this link is okay now */
    3927                 :         38 :                 ehc->i.flags = 0;
    3928                 :         38 :                 continue;
    3929                 :            : 
    3930                 :          0 :         rest_fail:
    3931                 :          0 :                 nr_fails++;
    3932         [ #  # ]:          0 :                 if (dev)
    3933                 :          0 :                         ata_eh_handle_dev_fail(dev, rc);
    3934                 :            : 
    3935         [ #  # ]:          0 :                 if (ap->pflags & ATA_PFLAG_FROZEN) {
    3936                 :            :                         /* PMP reset requires working host port.
    3937                 :            :                          * Can't retry if it's frozen.
    3938                 :            :                          */
    3939         [ #  # ]:          0 :                         if (sata_pmp_attached(ap))
    3940                 :          0 :                                 goto out;
    3941                 :            :                         break;
    3942                 :            :                 }
    3943                 :            :         }
    3944                 :            : 
    3945         [ -  + ]:         38 :         if (nr_fails)
    3946                 :          0 :                 goto retry;
    3947                 :            : 
    3948                 :         38 :  out:
    3949         [ -  + ]:         38 :         if (rc && r_failed_link)
    3950                 :          0 :                 *r_failed_link = link;
    3951                 :            : 
    3952                 :            :         DPRINTK("EXIT, rc=%d\n", rc);
    3953                 :            :         return rc;
    3954                 :            : }
    3955                 :            : 
    3956                 :            : /**
    3957                 :            :  *      ata_eh_finish - finish up EH
    3958                 :            :  *      @ap: host port to finish EH for
    3959                 :            :  *
    3960                 :            :  *      Recovery is complete.  Clean up EH states and retry or finish
    3961                 :            :  *      failed qcs.
    3962                 :            :  *
    3963                 :            :  *      LOCKING:
    3964                 :            :  *      None.
    3965                 :            :  */
    3966                 :         38 : void ata_eh_finish(struct ata_port *ap)
    3967                 :            : {
    3968                 :         38 :         struct ata_queued_cmd *qc;
    3969                 :         38 :         int tag;
    3970                 :            : 
    3971                 :            :         /* retry or finish qcs */
    3972   [ +  +  +  - ]:       1254 :         ata_qc_for_each_raw(ap, qc, tag) {
    3973         [ +  + ]:       1216 :                 if (!(qc->flags & ATA_QCFLAG_FAILED))
    3974                 :       1187 :                         continue;
    3975                 :            : 
    3976         [ -  + ]:         29 :                 if (qc->err_mask) {
    3977                 :            :                         /* FIXME: Once EH migration is complete,
    3978                 :            :                          * generate sense data in this function,
    3979                 :            :                          * considering both err_mask and tf.
    3980                 :            :                          */
    3981         [ #  # ]:          0 :                         if (qc->flags & ATA_QCFLAG_RETRY)
    3982                 :          0 :                                 ata_eh_qc_retry(qc);
    3983                 :            :                         else
    3984                 :          0 :                                 ata_eh_qc_complete(qc);
    3985                 :            :                 } else {
    3986         [ +  - ]:         29 :                         if (qc->flags & ATA_QCFLAG_SENSE_VALID) {
    3987                 :         29 :                                 ata_eh_qc_complete(qc);
    3988                 :            :                         } else {
    3989                 :            :                                 /* feed zero TF to sense generation */
    3990                 :          0 :                                 memset(&qc->result_tf, 0, sizeof(qc->result_tf));
    3991         [ #  # ]:          0 :                                 ata_eh_qc_retry(qc);
    3992                 :            :                         }
    3993                 :            :                 }
    3994                 :            :         }
    3995                 :            : 
    3996                 :            :         /* make sure nr_active_links is zero after EH */
    3997         [ -  + ]:         38 :         WARN_ON(ap->nr_active_links);
    3998                 :         38 :         ap->nr_active_links = 0;
    3999                 :         38 : }
    4000                 :            : 
    4001                 :            : /**
    4002                 :            :  *      ata_do_eh - do standard error handling
    4003                 :            :  *      @ap: host port to handle error for
    4004                 :            :  *
    4005                 :            :  *      @prereset: prereset method (can be NULL)
    4006                 :            :  *      @softreset: softreset method (can be NULL)
    4007                 :            :  *      @hardreset: hardreset method (can be NULL)
    4008                 :            :  *      @postreset: postreset method (can be NULL)
    4009                 :            :  *
    4010                 :            :  *      Perform standard error handling sequence.
    4011                 :            :  *
    4012                 :            :  *      LOCKING:
    4013                 :            :  *      Kernel thread context (may sleep).
    4014                 :            :  */
    4015                 :         38 : void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
    4016                 :            :                ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
    4017                 :            :                ata_postreset_fn_t postreset)
    4018                 :            : {
    4019                 :         38 :         struct ata_device *dev;
    4020                 :         38 :         int rc;
    4021                 :            : 
    4022                 :         38 :         ata_eh_autopsy(ap);
    4023                 :         38 :         ata_eh_report(ap);
    4024                 :            : 
    4025                 :         38 :         rc = ata_eh_recover(ap, prereset, softreset, hardreset, postreset,
    4026                 :            :                             NULL);
    4027         [ -  + ]:         38 :         if (rc) {
    4028         [ #  # ]:          0 :                 ata_for_each_dev(dev, &ap->link, ALL)
    4029                 :          0 :                         ata_dev_disable(dev);
    4030                 :            :         }
    4031                 :            : 
    4032                 :         38 :         ata_eh_finish(ap);
    4033                 :         38 : }
    4034                 :            : 
    4035                 :            : /**
    4036                 :            :  *      ata_std_error_handler - standard error handler
    4037                 :            :  *      @ap: host port to handle error for
    4038                 :            :  *
    4039                 :            :  *      Standard error handler
    4040                 :            :  *
    4041                 :            :  *      LOCKING:
    4042                 :            :  *      Kernel thread context (may sleep).
    4043                 :            :  */
    4044                 :          0 : void ata_std_error_handler(struct ata_port *ap)
    4045                 :            : {
    4046                 :          0 :         struct ata_port_operations *ops = ap->ops;
    4047                 :          0 :         ata_reset_fn_t hardreset = ops->hardreset;
    4048                 :            : 
    4049                 :            :         /* ignore built-in hardreset if SCR access is not available */
    4050   [ #  #  #  # ]:          0 :         if (hardreset == sata_std_hardreset && !sata_scr_valid(&ap->link))
    4051                 :          0 :                 hardreset = NULL;
    4052                 :            : 
    4053                 :          0 :         ata_do_eh(ap, ops->prereset, ops->softreset, hardreset, ops->postreset);
    4054                 :          0 : }
    4055                 :            : 
    4056                 :            : #ifdef CONFIG_PM
    4057                 :            : /**
    4058                 :            :  *      ata_eh_handle_port_suspend - perform port suspend operation
    4059                 :            :  *      @ap: port to suspend
    4060                 :            :  *
    4061                 :            :  *      Suspend @ap.
    4062                 :            :  *
    4063                 :            :  *      LOCKING:
    4064                 :            :  *      Kernel thread context (may sleep).
    4065                 :            :  */
    4066                 :         38 : static void ata_eh_handle_port_suspend(struct ata_port *ap)
    4067                 :            : {
    4068                 :         38 :         unsigned long flags;
    4069                 :         38 :         int rc = 0;
    4070                 :         38 :         struct ata_device *dev;
    4071                 :            : 
    4072                 :            :         /* are we suspending? */
    4073                 :         38 :         spin_lock_irqsave(ap->lock, flags);
    4074         [ -  + ]:         38 :         if (!(ap->pflags & ATA_PFLAG_PM_PENDING) ||
    4075         [ #  # ]:          0 :             ap->pm_mesg.event & PM_EVENT_RESUME) {
    4076                 :         38 :                 spin_unlock_irqrestore(ap->lock, flags);
    4077                 :         38 :                 return;
    4078                 :            :         }
    4079                 :          0 :         spin_unlock_irqrestore(ap->lock, flags);
    4080                 :            : 
    4081         [ #  # ]:          0 :         WARN_ON(ap->pflags & ATA_PFLAG_SUSPENDED);
    4082                 :            : 
    4083                 :            :         /*
    4084                 :            :          * If we have a ZPODD attached, check its zero
    4085                 :            :          * power ready status before the port is frozen.
    4086                 :            :          * Only needed for runtime suspend.
    4087                 :            :          */
    4088         [ #  # ]:          0 :         if (PMSG_IS_AUTO(ap->pm_mesg)) {
    4089         [ #  # ]:          0 :                 ata_for_each_dev(dev, &ap->link, ENABLED) {
    4090                 :          0 :                         if (zpodd_dev_enabled(dev))
    4091                 :            :                                 zpodd_on_suspend(dev);
    4092                 :            :                 }
    4093                 :            :         }
    4094                 :            : 
    4095                 :            :         /* tell ACPI we're suspending */
    4096                 :          0 :         rc = ata_acpi_on_suspend(ap);
    4097         [ #  # ]:          0 :         if (rc)
    4098                 :          0 :                 goto out;
    4099                 :            : 
    4100                 :            :         /* suspend */
    4101                 :          0 :         ata_eh_freeze_port(ap);
    4102                 :            : 
    4103         [ #  # ]:          0 :         if (ap->ops->port_suspend)
    4104                 :          0 :                 rc = ap->ops->port_suspend(ap, ap->pm_mesg);
    4105                 :            : 
    4106                 :          0 :         ata_acpi_set_state(ap, ap->pm_mesg);
    4107                 :          0 :  out:
    4108                 :            :         /* update the flags */
    4109                 :          0 :         spin_lock_irqsave(ap->lock, flags);
    4110                 :            : 
    4111                 :          0 :         ap->pflags &= ~ATA_PFLAG_PM_PENDING;
    4112         [ #  # ]:          0 :         if (rc == 0)
    4113                 :          0 :                 ap->pflags |= ATA_PFLAG_SUSPENDED;
    4114         [ #  # ]:          0 :         else if (ap->pflags & ATA_PFLAG_FROZEN)
    4115                 :          0 :                 ata_port_schedule_eh(ap);
    4116                 :            : 
    4117                 :          0 :         spin_unlock_irqrestore(ap->lock, flags);
    4118                 :            : 
    4119                 :            :         return;
    4120                 :            : }
    4121                 :            : 
    4122                 :            : /**
    4123                 :            :  *      ata_eh_handle_port_resume - perform port resume operation
    4124                 :            :  *      @ap: port to resume
    4125                 :            :  *
    4126                 :            :  *      Resume @ap.
    4127                 :            :  *
    4128                 :            :  *      LOCKING:
    4129                 :            :  *      Kernel thread context (may sleep).
    4130                 :            :  */
    4131                 :         38 : static void ata_eh_handle_port_resume(struct ata_port *ap)
    4132                 :            : {
    4133                 :         38 :         struct ata_link *link;
    4134                 :         38 :         struct ata_device *dev;
    4135                 :         38 :         unsigned long flags;
    4136                 :            : 
    4137                 :            :         /* are we resuming? */
    4138                 :         38 :         spin_lock_irqsave(ap->lock, flags);
    4139         [ -  + ]:         38 :         if (!(ap->pflags & ATA_PFLAG_PM_PENDING) ||
    4140         [ #  # ]:          0 :             !(ap->pm_mesg.event & PM_EVENT_RESUME)) {
    4141                 :         38 :                 spin_unlock_irqrestore(ap->lock, flags);
    4142                 :         38 :                 return;
    4143                 :            :         }
    4144                 :          0 :         spin_unlock_irqrestore(ap->lock, flags);
    4145                 :            : 
    4146         [ #  # ]:          0 :         WARN_ON(!(ap->pflags & ATA_PFLAG_SUSPENDED));
    4147                 :            : 
    4148                 :            :         /*
    4149                 :            :          * Error timestamps are in jiffies which doesn't run while
    4150                 :            :          * suspended and PHY events during resume isn't too uncommon.
    4151                 :            :          * When the two are combined, it can lead to unnecessary speed
    4152                 :            :          * downs if the machine is suspended and resumed repeatedly.
    4153                 :            :          * Clear error history.
    4154                 :            :          */
    4155         [ #  # ]:          0 :         ata_for_each_link(link, ap, HOST_FIRST)
    4156         [ #  # ]:          0 :                 ata_for_each_dev(dev, link, ALL)
    4157                 :          0 :                         ata_ering_clear(&dev->ering);
    4158                 :            : 
    4159                 :          0 :         ata_acpi_set_state(ap, ap->pm_mesg);
    4160                 :            : 
    4161         [ #  # ]:          0 :         if (ap->ops->port_resume)
    4162                 :          0 :                 ap->ops->port_resume(ap);
    4163                 :            : 
    4164                 :            :         /* tell ACPI that we're resuming */
    4165                 :          0 :         ata_acpi_on_resume(ap);
    4166                 :            : 
    4167                 :            :         /* update the flags */
    4168                 :          0 :         spin_lock_irqsave(ap->lock, flags);
    4169                 :          0 :         ap->pflags &= ~(ATA_PFLAG_PM_PENDING | ATA_PFLAG_SUSPENDED);
    4170                 :          0 :         spin_unlock_irqrestore(ap->lock, flags);
    4171                 :            : }
    4172                 :            : #endif /* CONFIG_PM */

Generated by: LCOV version 1.14