LCOV - code coverage report
Current view: top level - drivers/ata - libahci.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 0 1208 0.0 %
Date: 2022-03-28 16:04:14 Functions: 0 72 0.0 %
Branches: 0 594 0.0 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-or-later
       2                 :            : /*
       3                 :            :  *  libahci.c - Common AHCI SATA low-level routines
       4                 :            :  *
       5                 :            :  *  Maintained by:  Tejun Heo <tj@kernel.org>
       6                 :            :  *                  Please ALWAYS copy linux-ide@vger.kernel.org
       7                 :            :  *                  on emails.
       8                 :            :  *
       9                 :            :  *  Copyright 2004-2005 Red Hat, Inc.
      10                 :            :  *
      11                 :            :  * libata documentation is available via 'make {ps|pdf}docs',
      12                 :            :  * as Documentation/driver-api/libata.rst
      13                 :            :  *
      14                 :            :  * AHCI hardware documentation:
      15                 :            :  * http://www.intel.com/technology/serialata/pdf/rev1_0.pdf
      16                 :            :  * http://www.intel.com/technology/serialata/pdf/rev1_1.pdf
      17                 :            :  */
      18                 :            : 
      19                 :            : #include <linux/kernel.h>
      20                 :            : #include <linux/gfp.h>
      21                 :            : #include <linux/module.h>
      22                 :            : #include <linux/nospec.h>
      23                 :            : #include <linux/blkdev.h>
      24                 :            : #include <linux/delay.h>
      25                 :            : #include <linux/interrupt.h>
      26                 :            : #include <linux/dma-mapping.h>
      27                 :            : #include <linux/device.h>
      28                 :            : #include <scsi/scsi_host.h>
      29                 :            : #include <scsi/scsi_cmnd.h>
      30                 :            : #include <linux/libata.h>
      31                 :            : #include <linux/pci.h>
      32                 :            : #include "ahci.h"
      33                 :            : #include "libata.h"
      34                 :            : 
      35                 :            : static int ahci_skip_host_reset;
      36                 :            : int ahci_ignore_sss;
      37                 :            : EXPORT_SYMBOL_GPL(ahci_ignore_sss);
      38                 :            : 
      39                 :            : module_param_named(skip_host_reset, ahci_skip_host_reset, int, 0444);
      40                 :            : MODULE_PARM_DESC(skip_host_reset, "skip global host reset (0=don't skip, 1=skip)");
      41                 :            : 
      42                 :            : module_param_named(ignore_sss, ahci_ignore_sss, int, 0444);
      43                 :            : MODULE_PARM_DESC(ignore_sss, "Ignore staggered spinup flag (0=don't ignore, 1=ignore)");
      44                 :            : 
      45                 :            : static int ahci_set_lpm(struct ata_link *link, enum ata_lpm_policy policy,
      46                 :            :                         unsigned hints);
      47                 :            : static ssize_t ahci_led_show(struct ata_port *ap, char *buf);
      48                 :            : static ssize_t ahci_led_store(struct ata_port *ap, const char *buf,
      49                 :            :                               size_t size);
      50                 :            : static ssize_t ahci_transmit_led_message(struct ata_port *ap, u32 state,
      51                 :            :                                         ssize_t size);
      52                 :            : 
      53                 :            : 
      54                 :            : 
      55                 :            : static int ahci_scr_read(struct ata_link *link, unsigned int sc_reg, u32 *val);
      56                 :            : static int ahci_scr_write(struct ata_link *link, unsigned int sc_reg, u32 val);
      57                 :            : static bool ahci_qc_fill_rtf(struct ata_queued_cmd *qc);
      58                 :            : static int ahci_port_start(struct ata_port *ap);
      59                 :            : static void ahci_port_stop(struct ata_port *ap);
      60                 :            : static enum ata_completion_errors ahci_qc_prep(struct ata_queued_cmd *qc);
      61                 :            : static int ahci_pmp_qc_defer(struct ata_queued_cmd *qc);
      62                 :            : static void ahci_freeze(struct ata_port *ap);
      63                 :            : static void ahci_thaw(struct ata_port *ap);
      64                 :            : static void ahci_set_aggressive_devslp(struct ata_port *ap, bool sleep);
      65                 :            : static void ahci_enable_fbs(struct ata_port *ap);
      66                 :            : static void ahci_disable_fbs(struct ata_port *ap);
      67                 :            : static void ahci_pmp_attach(struct ata_port *ap);
      68                 :            : static void ahci_pmp_detach(struct ata_port *ap);
      69                 :            : static int ahci_softreset(struct ata_link *link, unsigned int *class,
      70                 :            :                           unsigned long deadline);
      71                 :            : static int ahci_pmp_retry_softreset(struct ata_link *link, unsigned int *class,
      72                 :            :                           unsigned long deadline);
      73                 :            : static int ahci_hardreset(struct ata_link *link, unsigned int *class,
      74                 :            :                           unsigned long deadline);
      75                 :            : static void ahci_postreset(struct ata_link *link, unsigned int *class);
      76                 :            : static void ahci_post_internal_cmd(struct ata_queued_cmd *qc);
      77                 :            : static void ahci_dev_config(struct ata_device *dev);
      78                 :            : #ifdef CONFIG_PM
      79                 :            : static int ahci_port_suspend(struct ata_port *ap, pm_message_t mesg);
      80                 :            : #endif
      81                 :            : static ssize_t ahci_activity_show(struct ata_device *dev, char *buf);
      82                 :            : static ssize_t ahci_activity_store(struct ata_device *dev,
      83                 :            :                                    enum sw_activity val);
      84                 :            : static void ahci_init_sw_activity(struct ata_link *link);
      85                 :            : 
      86                 :            : static ssize_t ahci_show_host_caps(struct device *dev,
      87                 :            :                                    struct device_attribute *attr, char *buf);
      88                 :            : static ssize_t ahci_show_host_cap2(struct device *dev,
      89                 :            :                                    struct device_attribute *attr, char *buf);
      90                 :            : static ssize_t ahci_show_host_version(struct device *dev,
      91                 :            :                                       struct device_attribute *attr, char *buf);
      92                 :            : static ssize_t ahci_show_port_cmd(struct device *dev,
      93                 :            :                                   struct device_attribute *attr, char *buf);
      94                 :            : static ssize_t ahci_read_em_buffer(struct device *dev,
      95                 :            :                                    struct device_attribute *attr, char *buf);
      96                 :            : static ssize_t ahci_store_em_buffer(struct device *dev,
      97                 :            :                                     struct device_attribute *attr,
      98                 :            :                                     const char *buf, size_t size);
      99                 :            : static ssize_t ahci_show_em_supported(struct device *dev,
     100                 :            :                                       struct device_attribute *attr, char *buf);
     101                 :            : static irqreturn_t ahci_single_level_irq_intr(int irq, void *dev_instance);
     102                 :            : 
     103                 :            : static DEVICE_ATTR(ahci_host_caps, S_IRUGO, ahci_show_host_caps, NULL);
     104                 :            : static DEVICE_ATTR(ahci_host_cap2, S_IRUGO, ahci_show_host_cap2, NULL);
     105                 :            : static DEVICE_ATTR(ahci_host_version, S_IRUGO, ahci_show_host_version, NULL);
     106                 :            : static DEVICE_ATTR(ahci_port_cmd, S_IRUGO, ahci_show_port_cmd, NULL);
     107                 :            : static DEVICE_ATTR(em_buffer, S_IWUSR | S_IRUGO,
     108                 :            :                    ahci_read_em_buffer, ahci_store_em_buffer);
     109                 :            : static DEVICE_ATTR(em_message_supported, S_IRUGO, ahci_show_em_supported, NULL);
     110                 :            : 
     111                 :            : struct device_attribute *ahci_shost_attrs[] = {
     112                 :            :         &dev_attr_link_power_management_policy,
     113                 :            :         &dev_attr_em_message_type,
     114                 :            :         &dev_attr_em_message,
     115                 :            :         &dev_attr_ahci_host_caps,
     116                 :            :         &dev_attr_ahci_host_cap2,
     117                 :            :         &dev_attr_ahci_host_version,
     118                 :            :         &dev_attr_ahci_port_cmd,
     119                 :            :         &dev_attr_em_buffer,
     120                 :            :         &dev_attr_em_message_supported,
     121                 :            :         NULL
     122                 :            : };
     123                 :            : EXPORT_SYMBOL_GPL(ahci_shost_attrs);
     124                 :            : 
     125                 :            : struct device_attribute *ahci_sdev_attrs[] = {
     126                 :            :         &dev_attr_sw_activity,
     127                 :            :         &dev_attr_unload_heads,
     128                 :            :         &dev_attr_ncq_prio_enable,
     129                 :            :         NULL
     130                 :            : };
     131                 :            : EXPORT_SYMBOL_GPL(ahci_sdev_attrs);
     132                 :            : 
     133                 :            : struct ata_port_operations ahci_ops = {
     134                 :            :         .inherits               = &sata_pmp_port_ops,
     135                 :            : 
     136                 :            :         .qc_defer               = ahci_pmp_qc_defer,
     137                 :            :         .qc_prep                = ahci_qc_prep,
     138                 :            :         .qc_issue               = ahci_qc_issue,
     139                 :            :         .qc_fill_rtf            = ahci_qc_fill_rtf,
     140                 :            : 
     141                 :            :         .freeze                 = ahci_freeze,
     142                 :            :         .thaw                   = ahci_thaw,
     143                 :            :         .softreset              = ahci_softreset,
     144                 :            :         .hardreset              = ahci_hardreset,
     145                 :            :         .postreset              = ahci_postreset,
     146                 :            :         .pmp_softreset          = ahci_softreset,
     147                 :            :         .error_handler          = ahci_error_handler,
     148                 :            :         .post_internal_cmd      = ahci_post_internal_cmd,
     149                 :            :         .dev_config             = ahci_dev_config,
     150                 :            : 
     151                 :            :         .scr_read               = ahci_scr_read,
     152                 :            :         .scr_write              = ahci_scr_write,
     153                 :            :         .pmp_attach             = ahci_pmp_attach,
     154                 :            :         .pmp_detach             = ahci_pmp_detach,
     155                 :            : 
     156                 :            :         .set_lpm                = ahci_set_lpm,
     157                 :            :         .em_show                = ahci_led_show,
     158                 :            :         .em_store               = ahci_led_store,
     159                 :            :         .sw_activity_show       = ahci_activity_show,
     160                 :            :         .sw_activity_store      = ahci_activity_store,
     161                 :            :         .transmit_led_message   = ahci_transmit_led_message,
     162                 :            : #ifdef CONFIG_PM
     163                 :            :         .port_suspend           = ahci_port_suspend,
     164                 :            :         .port_resume            = ahci_port_resume,
     165                 :            : #endif
     166                 :            :         .port_start             = ahci_port_start,
     167                 :            :         .port_stop              = ahci_port_stop,
     168                 :            : };
     169                 :            : EXPORT_SYMBOL_GPL(ahci_ops);
     170                 :            : 
     171                 :            : struct ata_port_operations ahci_pmp_retry_srst_ops = {
     172                 :            :         .inherits               = &ahci_ops,
     173                 :            :         .softreset              = ahci_pmp_retry_softreset,
     174                 :            : };
     175                 :            : EXPORT_SYMBOL_GPL(ahci_pmp_retry_srst_ops);
     176                 :            : 
     177                 :            : static bool ahci_em_messages __read_mostly = true;
     178                 :            : module_param(ahci_em_messages, bool, 0444);
     179                 :            : /* add other LED protocol types when they become supported */
     180                 :            : MODULE_PARM_DESC(ahci_em_messages,
     181                 :            :         "AHCI Enclosure Management Message control (0 = off, 1 = on)");
     182                 :            : 
     183                 :            : /* device sleep idle timeout in ms */
     184                 :            : static int devslp_idle_timeout __read_mostly = 1000;
     185                 :            : module_param(devslp_idle_timeout, int, 0644);
     186                 :            : MODULE_PARM_DESC(devslp_idle_timeout, "device sleep idle timeout");
     187                 :            : 
     188                 :          0 : static void ahci_enable_ahci(void __iomem *mmio)
     189                 :            : {
     190                 :          0 :         int i;
     191                 :          0 :         u32 tmp;
     192                 :            : 
     193                 :            :         /* turn on AHCI_EN */
     194                 :          0 :         tmp = readl(mmio + HOST_CTL);
     195         [ #  # ]:          0 :         if (tmp & HOST_AHCI_EN)
     196                 :            :                 return;
     197                 :            : 
     198                 :            :         /* Some controllers need AHCI_EN to be written multiple times.
     199                 :            :          * Try a few times before giving up.
     200                 :            :          */
     201         [ #  # ]:          0 :         for (i = 0; i < 5; i++) {
     202                 :          0 :                 tmp |= HOST_AHCI_EN;
     203                 :          0 :                 writel(tmp, mmio + HOST_CTL);
     204                 :          0 :                 tmp = readl(mmio + HOST_CTL);   /* flush && sanity check */
     205         [ #  # ]:          0 :                 if (tmp & HOST_AHCI_EN)
     206                 :            :                         return;
     207                 :          0 :                 msleep(10);
     208                 :            :         }
     209                 :            : 
     210                 :          0 :         WARN_ON(1);
     211                 :            : }
     212                 :            : 
     213                 :            : /**
     214                 :            :  *      ahci_rpm_get_port - Make sure the port is powered on
     215                 :            :  *      @ap: Port to power on
     216                 :            :  *
     217                 :            :  *      Whenever there is need to access the AHCI host registers outside of
     218                 :            :  *      normal execution paths, call this function to make sure the host is
     219                 :            :  *      actually powered on.
     220                 :            :  */
     221                 :          0 : static int ahci_rpm_get_port(struct ata_port *ap)
     222                 :            : {
     223                 :          0 :         return pm_runtime_get_sync(ap->dev);
     224                 :            : }
     225                 :            : 
     226                 :            : /**
     227                 :            :  *      ahci_rpm_put_port - Undoes ahci_rpm_get_port()
     228                 :            :  *      @ap: Port to power down
     229                 :            :  *
     230                 :            :  *      Undoes ahci_rpm_get_port() and possibly powers down the AHCI host
     231                 :            :  *      if it has no more active users.
     232                 :            :  */
     233                 :          0 : static void ahci_rpm_put_port(struct ata_port *ap)
     234                 :            : {
     235                 :          0 :         pm_runtime_put(ap->dev);
     236                 :            : }
     237                 :            : 
     238                 :          0 : static ssize_t ahci_show_host_caps(struct device *dev,
     239                 :            :                                    struct device_attribute *attr, char *buf)
     240                 :            : {
     241                 :          0 :         struct Scsi_Host *shost = class_to_shost(dev);
     242                 :          0 :         struct ata_port *ap = ata_shost_to_port(shost);
     243                 :          0 :         struct ahci_host_priv *hpriv = ap->host->private_data;
     244                 :            : 
     245                 :          0 :         return sprintf(buf, "%x\n", hpriv->cap);
     246                 :            : }
     247                 :            : 
     248                 :          0 : static ssize_t ahci_show_host_cap2(struct device *dev,
     249                 :            :                                    struct device_attribute *attr, char *buf)
     250                 :            : {
     251                 :          0 :         struct Scsi_Host *shost = class_to_shost(dev);
     252                 :          0 :         struct ata_port *ap = ata_shost_to_port(shost);
     253                 :          0 :         struct ahci_host_priv *hpriv = ap->host->private_data;
     254                 :            : 
     255                 :          0 :         return sprintf(buf, "%x\n", hpriv->cap2);
     256                 :            : }
     257                 :            : 
     258                 :          0 : static ssize_t ahci_show_host_version(struct device *dev,
     259                 :            :                                    struct device_attribute *attr, char *buf)
     260                 :            : {
     261                 :          0 :         struct Scsi_Host *shost = class_to_shost(dev);
     262                 :          0 :         struct ata_port *ap = ata_shost_to_port(shost);
     263                 :          0 :         struct ahci_host_priv *hpriv = ap->host->private_data;
     264                 :            : 
     265                 :          0 :         return sprintf(buf, "%x\n", hpriv->version);
     266                 :            : }
     267                 :            : 
     268                 :          0 : static ssize_t ahci_show_port_cmd(struct device *dev,
     269                 :            :                                   struct device_attribute *attr, char *buf)
     270                 :            : {
     271                 :          0 :         struct Scsi_Host *shost = class_to_shost(dev);
     272                 :          0 :         struct ata_port *ap = ata_shost_to_port(shost);
     273                 :          0 :         void __iomem *port_mmio = ahci_port_base(ap);
     274                 :          0 :         ssize_t ret;
     275                 :            : 
     276                 :          0 :         ahci_rpm_get_port(ap);
     277                 :          0 :         ret = sprintf(buf, "%x\n", readl(port_mmio + PORT_CMD));
     278                 :          0 :         ahci_rpm_put_port(ap);
     279                 :            : 
     280                 :          0 :         return ret;
     281                 :            : }
     282                 :            : 
     283                 :          0 : static ssize_t ahci_read_em_buffer(struct device *dev,
     284                 :            :                                    struct device_attribute *attr, char *buf)
     285                 :            : {
     286                 :          0 :         struct Scsi_Host *shost = class_to_shost(dev);
     287                 :          0 :         struct ata_port *ap = ata_shost_to_port(shost);
     288                 :          0 :         struct ahci_host_priv *hpriv = ap->host->private_data;
     289                 :          0 :         void __iomem *mmio = hpriv->mmio;
     290                 :          0 :         void __iomem *em_mmio = mmio + hpriv->em_loc;
     291                 :          0 :         u32 em_ctl, msg;
     292                 :          0 :         unsigned long flags;
     293                 :          0 :         size_t count;
     294                 :          0 :         int i;
     295                 :            : 
     296                 :          0 :         ahci_rpm_get_port(ap);
     297                 :          0 :         spin_lock_irqsave(ap->lock, flags);
     298                 :            : 
     299                 :          0 :         em_ctl = readl(mmio + HOST_EM_CTL);
     300   [ #  #  #  # ]:          0 :         if (!(ap->flags & ATA_FLAG_EM) || em_ctl & EM_CTL_XMT ||
     301         [ #  # ]:          0 :             !(hpriv->em_msg_type & EM_MSG_TYPE_SGPIO)) {
     302                 :          0 :                 spin_unlock_irqrestore(ap->lock, flags);
     303                 :          0 :                 ahci_rpm_put_port(ap);
     304                 :          0 :                 return -EINVAL;
     305                 :            :         }
     306                 :            : 
     307         [ #  # ]:          0 :         if (!(em_ctl & EM_CTL_MR)) {
     308                 :          0 :                 spin_unlock_irqrestore(ap->lock, flags);
     309                 :          0 :                 ahci_rpm_put_port(ap);
     310                 :          0 :                 return -EAGAIN;
     311                 :            :         }
     312                 :            : 
     313         [ #  # ]:          0 :         if (!(em_ctl & EM_CTL_SMB))
     314                 :          0 :                 em_mmio += hpriv->em_buf_sz;
     315                 :            : 
     316                 :          0 :         count = hpriv->em_buf_sz;
     317                 :            : 
     318                 :            :         /* the count should not be larger than PAGE_SIZE */
     319         [ #  # ]:          0 :         if (count > PAGE_SIZE) {
     320         [ #  # ]:          0 :                 if (printk_ratelimit())
     321                 :          0 :                         ata_port_warn(ap,
     322                 :            :                                       "EM read buffer size too large: "
     323                 :            :                                       "buffer size %u, page size %lu\n",
     324                 :            :                                       hpriv->em_buf_sz, PAGE_SIZE);
     325                 :            :                 count = PAGE_SIZE;
     326                 :            :         }
     327                 :            : 
     328         [ #  # ]:          0 :         for (i = 0; i < count; i += 4) {
     329                 :          0 :                 msg = readl(em_mmio + i);
     330                 :          0 :                 buf[i] = msg & 0xff;
     331                 :          0 :                 buf[i + 1] = (msg >> 8) & 0xff;
     332                 :          0 :                 buf[i + 2] = (msg >> 16) & 0xff;
     333                 :          0 :                 buf[i + 3] = (msg >> 24) & 0xff;
     334                 :            :         }
     335                 :            : 
     336                 :          0 :         spin_unlock_irqrestore(ap->lock, flags);
     337                 :          0 :         ahci_rpm_put_port(ap);
     338                 :            : 
     339                 :          0 :         return i;
     340                 :            : }
     341                 :            : 
     342                 :          0 : static ssize_t ahci_store_em_buffer(struct device *dev,
     343                 :            :                                     struct device_attribute *attr,
     344                 :            :                                     const char *buf, size_t size)
     345                 :            : {
     346                 :          0 :         struct Scsi_Host *shost = class_to_shost(dev);
     347         [ #  # ]:          0 :         struct ata_port *ap = ata_shost_to_port(shost);
     348                 :          0 :         struct ahci_host_priv *hpriv = ap->host->private_data;
     349                 :          0 :         void __iomem *mmio = hpriv->mmio;
     350                 :          0 :         void __iomem *em_mmio = mmio + hpriv->em_loc;
     351                 :          0 :         const unsigned char *msg_buf = buf;
     352                 :          0 :         u32 em_ctl, msg;
     353                 :          0 :         unsigned long flags;
     354                 :          0 :         int i;
     355                 :            : 
     356                 :            :         /* check size validity */
     357         [ #  # ]:          0 :         if (!(ap->flags & ATA_FLAG_EM) ||
     358         [ #  # ]:          0 :             !(hpriv->em_msg_type & EM_MSG_TYPE_SGPIO) ||
     359   [ #  #  #  # ]:          0 :             size % 4 || size > hpriv->em_buf_sz)
     360                 :            :                 return -EINVAL;
     361                 :            : 
     362                 :          0 :         ahci_rpm_get_port(ap);
     363                 :          0 :         spin_lock_irqsave(ap->lock, flags);
     364                 :            : 
     365                 :          0 :         em_ctl = readl(mmio + HOST_EM_CTL);
     366         [ #  # ]:          0 :         if (em_ctl & EM_CTL_TM) {
     367                 :          0 :                 spin_unlock_irqrestore(ap->lock, flags);
     368                 :          0 :                 ahci_rpm_put_port(ap);
     369                 :          0 :                 return -EBUSY;
     370                 :            :         }
     371                 :            : 
     372         [ #  # ]:          0 :         for (i = 0; i < size; i += 4) {
     373                 :          0 :                 msg = msg_buf[i] | msg_buf[i + 1] << 8 |
     374                 :          0 :                       msg_buf[i + 2] << 16 | msg_buf[i + 3] << 24;
     375                 :          0 :                 writel(msg, em_mmio + i);
     376                 :            :         }
     377                 :            : 
     378                 :          0 :         writel(em_ctl | EM_CTL_TM, mmio + HOST_EM_CTL);
     379                 :            : 
     380                 :          0 :         spin_unlock_irqrestore(ap->lock, flags);
     381                 :          0 :         ahci_rpm_put_port(ap);
     382                 :            : 
     383                 :          0 :         return size;
     384                 :            : }
     385                 :            : 
     386                 :          0 : static ssize_t ahci_show_em_supported(struct device *dev,
     387                 :            :                                       struct device_attribute *attr, char *buf)
     388                 :            : {
     389                 :          0 :         struct Scsi_Host *shost = class_to_shost(dev);
     390                 :          0 :         struct ata_port *ap = ata_shost_to_port(shost);
     391                 :          0 :         struct ahci_host_priv *hpriv = ap->host->private_data;
     392                 :          0 :         void __iomem *mmio = hpriv->mmio;
     393                 :          0 :         u32 em_ctl;
     394                 :            : 
     395                 :          0 :         ahci_rpm_get_port(ap);
     396                 :          0 :         em_ctl = readl(mmio + HOST_EM_CTL);
     397                 :          0 :         ahci_rpm_put_port(ap);
     398                 :            : 
     399                 :          0 :         return sprintf(buf, "%s%s%s%s\n",
     400         [ #  # ]:          0 :                        em_ctl & EM_CTL_LED ? "led " : "",
     401         [ #  # ]:          0 :                        em_ctl & EM_CTL_SAFTE ? "saf-te " : "",
     402         [ #  # ]:          0 :                        em_ctl & EM_CTL_SES ? "ses-2 " : "",
     403         [ #  # ]:          0 :                        em_ctl & EM_CTL_SGPIO ? "sgpio " : "");
     404                 :            : }
     405                 :            : 
     406                 :            : /**
     407                 :            :  *      ahci_save_initial_config - Save and fixup initial config values
     408                 :            :  *      @dev: target AHCI device
     409                 :            :  *      @hpriv: host private area to store config values
     410                 :            :  *
     411                 :            :  *      Some registers containing configuration info might be setup by
     412                 :            :  *      BIOS and might be cleared on reset.  This function saves the
     413                 :            :  *      initial values of those registers into @hpriv such that they
     414                 :            :  *      can be restored after controller reset.
     415                 :            :  *
     416                 :            :  *      If inconsistent, config values are fixed up by this function.
     417                 :            :  *
     418                 :            :  *      If it is not set already this function sets hpriv->start_engine to
     419                 :            :  *      ahci_start_engine.
     420                 :            :  *
     421                 :            :  *      LOCKING:
     422                 :            :  *      None.
     423                 :            :  */
     424                 :          0 : void ahci_save_initial_config(struct device *dev, struct ahci_host_priv *hpriv)
     425                 :            : {
     426                 :          0 :         void __iomem *mmio = hpriv->mmio;
     427                 :          0 :         u32 cap, cap2, vers, port_map;
     428                 :          0 :         int i;
     429                 :            : 
     430                 :            :         /* make sure AHCI mode is enabled before accessing CAP */
     431                 :          0 :         ahci_enable_ahci(mmio);
     432                 :            : 
     433                 :            :         /* Values prefixed with saved_ are written back to host after
     434                 :            :          * reset.  Values without are used for driver operation.
     435                 :            :          */
     436                 :          0 :         hpriv->saved_cap = cap = readl(mmio + HOST_CAP);
     437                 :          0 :         hpriv->saved_port_map = port_map = readl(mmio + HOST_PORTS_IMPL);
     438                 :            : 
     439                 :            :         /* CAP2 register is only defined for AHCI 1.2 and later */
     440                 :          0 :         vers = readl(mmio + HOST_VERSION);
     441   [ #  #  #  # ]:          0 :         if ((vers >> 16) > 1 ||
     442         [ #  # ]:          0 :            ((vers >> 16) == 1 && (vers & 0xFFFF) >= 0x200))
     443                 :          0 :                 hpriv->saved_cap2 = cap2 = readl(mmio + HOST_CAP2);
     444                 :            :         else
     445                 :          0 :                 hpriv->saved_cap2 = cap2 = 0;
     446                 :            : 
     447                 :            :         /* some chips have errata preventing 64bit use */
     448   [ #  #  #  # ]:          0 :         if ((cap & HOST_CAP_64) && (hpriv->flags & AHCI_HFLAG_32BIT_ONLY)) {
     449                 :          0 :                 dev_info(dev, "controller can't do 64bit DMA, forcing 32bit\n");
     450                 :          0 :                 cap &= ~HOST_CAP_64;
     451                 :            :         }
     452                 :            : 
     453   [ #  #  #  # ]:          0 :         if ((cap & HOST_CAP_NCQ) && (hpriv->flags & AHCI_HFLAG_NO_NCQ)) {
     454                 :          0 :                 dev_info(dev, "controller can't do NCQ, turning off CAP_NCQ\n");
     455                 :          0 :                 cap &= ~HOST_CAP_NCQ;
     456                 :            :         }
     457                 :            : 
     458   [ #  #  #  # ]:          0 :         if (!(cap & HOST_CAP_NCQ) && (hpriv->flags & AHCI_HFLAG_YES_NCQ)) {
     459                 :          0 :                 dev_info(dev, "controller can do NCQ, turning on CAP_NCQ\n");
     460                 :          0 :                 cap |= HOST_CAP_NCQ;
     461                 :            :         }
     462                 :            : 
     463   [ #  #  #  # ]:          0 :         if ((cap & HOST_CAP_PMP) && (hpriv->flags & AHCI_HFLAG_NO_PMP)) {
     464                 :          0 :                 dev_info(dev, "controller can't do PMP, turning off CAP_PMP\n");
     465                 :          0 :                 cap &= ~HOST_CAP_PMP;
     466                 :            :         }
     467                 :            : 
     468   [ #  #  #  # ]:          0 :         if ((cap & HOST_CAP_SNTF) && (hpriv->flags & AHCI_HFLAG_NO_SNTF)) {
     469                 :          0 :                 dev_info(dev,
     470                 :            :                          "controller can't do SNTF, turning off CAP_SNTF\n");
     471                 :          0 :                 cap &= ~HOST_CAP_SNTF;
     472                 :            :         }
     473                 :            : 
     474   [ #  #  #  # ]:          0 :         if ((cap2 & HOST_CAP2_SDS) && (hpriv->flags & AHCI_HFLAG_NO_DEVSLP)) {
     475                 :          0 :                 dev_info(dev,
     476                 :            :                          "controller can't do DEVSLP, turning off\n");
     477                 :          0 :                 cap2 &= ~HOST_CAP2_SDS;
     478                 :          0 :                 cap2 &= ~HOST_CAP2_SADM;
     479                 :            :         }
     480                 :            : 
     481   [ #  #  #  # ]:          0 :         if (!(cap & HOST_CAP_FBS) && (hpriv->flags & AHCI_HFLAG_YES_FBS)) {
     482                 :          0 :                 dev_info(dev, "controller can do FBS, turning on CAP_FBS\n");
     483                 :          0 :                 cap |= HOST_CAP_FBS;
     484                 :            :         }
     485                 :            : 
     486   [ #  #  #  # ]:          0 :         if ((cap & HOST_CAP_FBS) && (hpriv->flags & AHCI_HFLAG_NO_FBS)) {
     487                 :          0 :                 dev_info(dev, "controller can't do FBS, turning off CAP_FBS\n");
     488                 :          0 :                 cap &= ~HOST_CAP_FBS;
     489                 :            :         }
     490                 :            : 
     491   [ #  #  #  # ]:          0 :         if (!(cap & HOST_CAP_ALPM) && (hpriv->flags & AHCI_HFLAG_YES_ALPM)) {
     492                 :          0 :                 dev_info(dev, "controller can do ALPM, turning on CAP_ALPM\n");
     493                 :          0 :                 cap |= HOST_CAP_ALPM;
     494                 :            :         }
     495                 :            : 
     496   [ #  #  #  # ]:          0 :         if (hpriv->force_port_map && port_map != hpriv->force_port_map) {
     497                 :          0 :                 dev_info(dev, "forcing port_map 0x%x -> 0x%x\n",
     498                 :            :                          port_map, hpriv->force_port_map);
     499                 :          0 :                 port_map = hpriv->force_port_map;
     500                 :          0 :                 hpriv->saved_port_map = port_map;
     501                 :            :         }
     502                 :            : 
     503         [ #  # ]:          0 :         if (hpriv->mask_port_map) {
     504                 :          0 :                 dev_warn(dev, "masking port_map 0x%x -> 0x%x\n",
     505                 :            :                         port_map,
     506                 :            :                         port_map & hpriv->mask_port_map);
     507                 :          0 :                 port_map &= hpriv->mask_port_map;
     508                 :            :         }
     509                 :            : 
     510                 :            :         /* cross check port_map and cap.n_ports */
     511         [ #  # ]:          0 :         if (port_map) {
     512                 :            :                 int map_ports = 0;
     513                 :            : 
     514         [ #  # ]:          0 :                 for (i = 0; i < AHCI_MAX_PORTS; i++)
     515         [ #  # ]:          0 :                         if (port_map & (1 << i))
     516                 :          0 :                                 map_ports++;
     517                 :            : 
     518                 :            :                 /* If PI has more ports than n_ports, whine, clear
     519                 :            :                  * port_map and let it be generated from n_ports.
     520                 :            :                  */
     521         [ #  # ]:          0 :                 if (map_ports > ahci_nr_ports(cap)) {
     522                 :          0 :                         dev_warn(dev,
     523                 :            :                                  "implemented port map (0x%x) contains more ports than nr_ports (%u), using nr_ports\n",
     524                 :            :                                  port_map, ahci_nr_ports(cap));
     525                 :          0 :                         port_map = 0;
     526                 :            :                 }
     527                 :            :         }
     528                 :            : 
     529                 :            :         /* fabricate port_map from cap.nr_ports for < AHCI 1.3 */
     530         [ #  # ]:          0 :         if (!port_map && vers < 0x10300) {
     531                 :          0 :                 port_map = (1 << ahci_nr_ports(cap)) - 1;
     532                 :          0 :                 dev_warn(dev, "forcing PORTS_IMPL to 0x%x\n", port_map);
     533                 :            : 
     534                 :            :                 /* write the fixed up value to the PI register */
     535                 :          0 :                 hpriv->saved_port_map = port_map;
     536                 :            :         }
     537                 :            : 
     538                 :            :         /* record values to use during operation */
     539                 :          0 :         hpriv->cap = cap;
     540                 :          0 :         hpriv->cap2 = cap2;
     541                 :          0 :         hpriv->version = readl(mmio + HOST_VERSION);
     542                 :          0 :         hpriv->port_map = port_map;
     543                 :            : 
     544         [ #  # ]:          0 :         if (!hpriv->start_engine)
     545                 :          0 :                 hpriv->start_engine = ahci_start_engine;
     546                 :            : 
     547         [ #  # ]:          0 :         if (!hpriv->stop_engine)
     548                 :          0 :                 hpriv->stop_engine = ahci_stop_engine;
     549                 :            : 
     550         [ #  # ]:          0 :         if (!hpriv->irq_handler)
     551                 :          0 :                 hpriv->irq_handler = ahci_single_level_irq_intr;
     552                 :          0 : }
     553                 :            : EXPORT_SYMBOL_GPL(ahci_save_initial_config);
     554                 :            : 
     555                 :            : /**
     556                 :            :  *      ahci_restore_initial_config - Restore initial config
     557                 :            :  *      @host: target ATA host
     558                 :            :  *
     559                 :            :  *      Restore initial config stored by ahci_save_initial_config().
     560                 :            :  *
     561                 :            :  *      LOCKING:
     562                 :            :  *      None.
     563                 :            :  */
     564                 :          0 : static void ahci_restore_initial_config(struct ata_host *host)
     565                 :            : {
     566                 :          0 :         struct ahci_host_priv *hpriv = host->private_data;
     567                 :          0 :         void __iomem *mmio = hpriv->mmio;
     568                 :            : 
     569                 :          0 :         writel(hpriv->saved_cap, mmio + HOST_CAP);
     570         [ #  # ]:          0 :         if (hpriv->saved_cap2)
     571                 :          0 :                 writel(hpriv->saved_cap2, mmio + HOST_CAP2);
     572                 :          0 :         writel(hpriv->saved_port_map, mmio + HOST_PORTS_IMPL);
     573                 :          0 :         (void) readl(mmio + HOST_PORTS_IMPL);   /* flush */
     574                 :          0 : }
     575                 :            : 
     576                 :          0 : static unsigned ahci_scr_offset(struct ata_port *ap, unsigned int sc_reg)
     577                 :            : {
     578                 :          0 :         static const int offset[] = {
     579                 :            :                 [SCR_STATUS]            = PORT_SCR_STAT,
     580                 :            :                 [SCR_CONTROL]           = PORT_SCR_CTL,
     581                 :            :                 [SCR_ERROR]             = PORT_SCR_ERR,
     582                 :            :                 [SCR_ACTIVE]            = PORT_SCR_ACT,
     583                 :            :                 [SCR_NOTIFICATION]      = PORT_SCR_NTF,
     584                 :            :         };
     585                 :          0 :         struct ahci_host_priv *hpriv = ap->host->private_data;
     586                 :            : 
     587   [ #  #  #  # ]:          0 :         if (sc_reg < ARRAY_SIZE(offset) &&
     588   [ #  #  #  # ]:          0 :             (sc_reg != SCR_NOTIFICATION || (hpriv->cap & HOST_CAP_SNTF)))
     589                 :          0 :                 return offset[sc_reg];
     590                 :            :         return 0;
     591                 :            : }
     592                 :            : 
     593                 :          0 : static int ahci_scr_read(struct ata_link *link, unsigned int sc_reg, u32 *val)
     594                 :            : {
     595         [ #  # ]:          0 :         void __iomem *port_mmio = ahci_port_base(link->ap);
     596         [ #  # ]:          0 :         int offset = ahci_scr_offset(link->ap, sc_reg);
     597                 :            : 
     598         [ #  # ]:          0 :         if (offset) {
     599                 :          0 :                 *val = readl(port_mmio + offset);
     600                 :          0 :                 return 0;
     601                 :            :         }
     602                 :            :         return -EINVAL;
     603                 :            : }
     604                 :            : 
     605                 :          0 : static int ahci_scr_write(struct ata_link *link, unsigned int sc_reg, u32 val)
     606                 :            : {
     607         [ #  # ]:          0 :         void __iomem *port_mmio = ahci_port_base(link->ap);
     608         [ #  # ]:          0 :         int offset = ahci_scr_offset(link->ap, sc_reg);
     609                 :            : 
     610         [ #  # ]:          0 :         if (offset) {
     611                 :          0 :                 writel(val, port_mmio + offset);
     612                 :          0 :                 return 0;
     613                 :            :         }
     614                 :            :         return -EINVAL;
     615                 :            : }
     616                 :            : 
     617                 :          0 : void ahci_start_engine(struct ata_port *ap)
     618                 :            : {
     619                 :          0 :         void __iomem *port_mmio = ahci_port_base(ap);
     620                 :          0 :         u32 tmp;
     621                 :            : 
     622                 :            :         /* start DMA */
     623                 :          0 :         tmp = readl(port_mmio + PORT_CMD);
     624                 :          0 :         tmp |= PORT_CMD_START;
     625                 :          0 :         writel(tmp, port_mmio + PORT_CMD);
     626                 :          0 :         readl(port_mmio + PORT_CMD); /* flush */
     627                 :          0 : }
     628                 :            : EXPORT_SYMBOL_GPL(ahci_start_engine);
     629                 :            : 
     630                 :          0 : int ahci_stop_engine(struct ata_port *ap)
     631                 :            : {
     632         [ #  # ]:          0 :         void __iomem *port_mmio = ahci_port_base(ap);
     633                 :          0 :         struct ahci_host_priv *hpriv = ap->host->private_data;
     634                 :          0 :         u32 tmp;
     635                 :            : 
     636                 :            :         /*
     637                 :            :          * On some controllers, stopping a port's DMA engine while the port
     638                 :            :          * is in ALPM state (partial or slumber) results in failures on
     639                 :            :          * subsequent DMA engine starts.  For those controllers, put the
     640                 :            :          * port back in active state before stopping its DMA engine.
     641                 :            :          */
     642         [ #  # ]:          0 :         if ((hpriv->flags & AHCI_HFLAG_WAKE_BEFORE_STOP) &&
     643   [ #  #  #  # ]:          0 :             (ap->link.lpm_policy > ATA_LPM_MAX_POWER) &&
     644                 :          0 :             ahci_set_lpm(&ap->link, ATA_LPM_MAX_POWER, ATA_LPM_WAKE_ONLY)) {
     645                 :          0 :                 dev_err(ap->host->dev, "Failed to wake up port before engine stop\n");
     646                 :          0 :                 return -EIO;
     647                 :            :         }
     648                 :            : 
     649                 :          0 :         tmp = readl(port_mmio + PORT_CMD);
     650                 :            : 
     651                 :            :         /* check if the HBA is idle */
     652         [ #  # ]:          0 :         if ((tmp & (PORT_CMD_START | PORT_CMD_LIST_ON)) == 0)
     653                 :            :                 return 0;
     654                 :            : 
     655                 :            :         /*
     656                 :            :          * Don't try to issue commands but return with ENODEV if the
     657                 :            :          * AHCI controller not available anymore (e.g. due to PCIe hot
     658                 :            :          * unplugging). Otherwise a 500ms delay for each port is added.
     659                 :            :          */
     660         [ #  # ]:          0 :         if (tmp == 0xffffffff) {
     661                 :          0 :                 dev_err(ap->host->dev, "AHCI controller unavailable!\n");
     662                 :          0 :                 return -ENODEV;
     663                 :            :         }
     664                 :            : 
     665                 :            :         /* setting HBA to idle */
     666                 :          0 :         tmp &= ~PORT_CMD_START;
     667                 :          0 :         writel(tmp, port_mmio + PORT_CMD);
     668                 :            : 
     669                 :            :         /* wait for engine to stop. This could be as long as 500 msec */
     670                 :          0 :         tmp = ata_wait_register(ap, port_mmio + PORT_CMD,
     671                 :            :                                 PORT_CMD_LIST_ON, PORT_CMD_LIST_ON, 1, 500);
     672         [ #  # ]:          0 :         if (tmp & PORT_CMD_LIST_ON)
     673                 :          0 :                 return -EIO;
     674                 :            : 
     675                 :            :         return 0;
     676                 :            : }
     677                 :            : EXPORT_SYMBOL_GPL(ahci_stop_engine);
     678                 :            : 
     679                 :          0 : void ahci_start_fis_rx(struct ata_port *ap)
     680                 :            : {
     681         [ #  # ]:          0 :         void __iomem *port_mmio = ahci_port_base(ap);
     682                 :          0 :         struct ahci_host_priv *hpriv = ap->host->private_data;
     683                 :          0 :         struct ahci_port_priv *pp = ap->private_data;
     684                 :          0 :         u32 tmp;
     685                 :            : 
     686                 :            :         /* set FIS registers */
     687         [ #  # ]:          0 :         if (hpriv->cap & HOST_CAP_64)
     688                 :          0 :                 writel((pp->cmd_slot_dma >> 16) >> 16,
     689                 :          0 :                        port_mmio + PORT_LST_ADDR_HI);
     690                 :          0 :         writel(pp->cmd_slot_dma & 0xffffffff, port_mmio + PORT_LST_ADDR);
     691                 :            : 
     692         [ #  # ]:          0 :         if (hpriv->cap & HOST_CAP_64)
     693                 :          0 :                 writel((pp->rx_fis_dma >> 16) >> 16,
     694                 :          0 :                        port_mmio + PORT_FIS_ADDR_HI);
     695                 :          0 :         writel(pp->rx_fis_dma & 0xffffffff, port_mmio + PORT_FIS_ADDR);
     696                 :            : 
     697                 :            :         /* enable FIS reception */
     698                 :          0 :         tmp = readl(port_mmio + PORT_CMD);
     699                 :          0 :         tmp |= PORT_CMD_FIS_RX;
     700                 :          0 :         writel(tmp, port_mmio + PORT_CMD);
     701                 :            : 
     702                 :            :         /* flush */
     703                 :          0 :         readl(port_mmio + PORT_CMD);
     704                 :          0 : }
     705                 :            : EXPORT_SYMBOL_GPL(ahci_start_fis_rx);
     706                 :            : 
     707                 :          0 : static int ahci_stop_fis_rx(struct ata_port *ap)
     708                 :            : {
     709                 :          0 :         void __iomem *port_mmio = ahci_port_base(ap);
     710                 :          0 :         u32 tmp;
     711                 :            : 
     712                 :            :         /* disable FIS reception */
     713                 :          0 :         tmp = readl(port_mmio + PORT_CMD);
     714                 :          0 :         tmp &= ~PORT_CMD_FIS_RX;
     715                 :          0 :         writel(tmp, port_mmio + PORT_CMD);
     716                 :            : 
     717                 :            :         /* wait for completion, spec says 500ms, give it 1000 */
     718                 :          0 :         tmp = ata_wait_register(ap, port_mmio + PORT_CMD, PORT_CMD_FIS_ON,
     719                 :            :                                 PORT_CMD_FIS_ON, 10, 1000);
     720         [ #  # ]:          0 :         if (tmp & PORT_CMD_FIS_ON)
     721                 :          0 :                 return -EBUSY;
     722                 :            : 
     723                 :            :         return 0;
     724                 :            : }
     725                 :            : 
     726                 :          0 : static void ahci_power_up(struct ata_port *ap)
     727                 :            : {
     728                 :          0 :         struct ahci_host_priv *hpriv = ap->host->private_data;
     729                 :          0 :         void __iomem *port_mmio = ahci_port_base(ap);
     730                 :          0 :         u32 cmd;
     731                 :            : 
     732                 :          0 :         cmd = readl(port_mmio + PORT_CMD) & ~PORT_CMD_ICC_MASK;
     733                 :            : 
     734                 :            :         /* spin up device */
     735         [ #  # ]:          0 :         if (hpriv->cap & HOST_CAP_SSS) {
     736                 :          0 :                 cmd |= PORT_CMD_SPIN_UP;
     737                 :          0 :                 writel(cmd, port_mmio + PORT_CMD);
     738                 :            :         }
     739                 :            : 
     740                 :            :         /* wake up link */
     741                 :          0 :         writel(cmd | PORT_CMD_ICC_ACTIVE, port_mmio + PORT_CMD);
     742                 :            : }
     743                 :            : 
     744                 :          0 : static int ahci_set_lpm(struct ata_link *link, enum ata_lpm_policy policy,
     745                 :            :                         unsigned int hints)
     746                 :            : {
     747                 :          0 :         struct ata_port *ap = link->ap;
     748                 :          0 :         struct ahci_host_priv *hpriv = ap->host->private_data;
     749                 :          0 :         struct ahci_port_priv *pp = ap->private_data;
     750         [ #  # ]:          0 :         void __iomem *port_mmio = ahci_port_base(ap);
     751                 :            : 
     752         [ #  # ]:          0 :         if (policy != ATA_LPM_MAX_POWER) {
     753                 :            :                 /* wakeup flag only applies to the max power policy */
     754                 :          0 :                 hints &= ~ATA_LPM_WAKE_ONLY;
     755                 :            : 
     756                 :            :                 /*
     757                 :            :                  * Disable interrupts on Phy Ready. This keeps us from
     758                 :            :                  * getting woken up due to spurious phy ready
     759                 :            :                  * interrupts.
     760                 :            :                  */
     761                 :          0 :                 pp->intr_mask &= ~PORT_IRQ_PHYRDY;
     762                 :          0 :                 writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK);
     763                 :            : 
     764                 :          0 :                 sata_link_scr_lpm(link, policy, false);
     765                 :            :         }
     766                 :            : 
     767         [ #  # ]:          0 :         if (hpriv->cap & HOST_CAP_ALPM) {
     768                 :          0 :                 u32 cmd = readl(port_mmio + PORT_CMD);
     769                 :            : 
     770   [ #  #  #  # ]:          0 :                 if (policy == ATA_LPM_MAX_POWER || !(hints & ATA_LPM_HIPM)) {
     771         [ #  # ]:          0 :                         if (!(hints & ATA_LPM_WAKE_ONLY))
     772                 :          0 :                                 cmd &= ~(PORT_CMD_ASP | PORT_CMD_ALPE);
     773                 :          0 :                         cmd |= PORT_CMD_ICC_ACTIVE;
     774                 :            : 
     775                 :          0 :                         writel(cmd, port_mmio + PORT_CMD);
     776                 :          0 :                         readl(port_mmio + PORT_CMD);
     777                 :            : 
     778                 :            :                         /* wait 10ms to be sure we've come out of LPM state */
     779                 :          0 :                         ata_msleep(ap, 10);
     780                 :            : 
     781         [ #  # ]:          0 :                         if (hints & ATA_LPM_WAKE_ONLY)
     782                 :            :                                 return 0;
     783                 :            :                 } else {
     784                 :          0 :                         cmd |= PORT_CMD_ALPE;
     785         [ #  # ]:          0 :                         if (policy == ATA_LPM_MIN_POWER)
     786                 :          0 :                                 cmd |= PORT_CMD_ASP;
     787         [ #  # ]:          0 :                         else if (policy == ATA_LPM_MIN_POWER_WITH_PARTIAL)
     788                 :          0 :                                 cmd &= ~PORT_CMD_ASP;
     789                 :            : 
     790                 :            :                         /* write out new cmd value */
     791                 :          0 :                         writel(cmd, port_mmio + PORT_CMD);
     792                 :            :                 }
     793                 :            :         }
     794                 :            : 
     795                 :            :         /* set aggressive device sleep */
     796         [ #  # ]:          0 :         if ((hpriv->cap2 & HOST_CAP2_SDS) &&
     797                 :          0 :             (hpriv->cap2 & HOST_CAP2_SADM) &&
     798         [ #  # ]:          0 :             (link->device->flags & ATA_DFLAG_DEVSLP)) {
     799         [ #  # ]:          0 :                 if (policy == ATA_LPM_MIN_POWER ||
     800                 :            :                     policy == ATA_LPM_MIN_POWER_WITH_PARTIAL)
     801                 :          0 :                         ahci_set_aggressive_devslp(ap, true);
     802                 :            :                 else
     803                 :          0 :                         ahci_set_aggressive_devslp(ap, false);
     804                 :            :         }
     805                 :            : 
     806         [ #  # ]:          0 :         if (policy == ATA_LPM_MAX_POWER) {
     807                 :          0 :                 sata_link_scr_lpm(link, policy, false);
     808                 :            : 
     809                 :            :                 /* turn PHYRDY IRQ back on */
     810                 :          0 :                 pp->intr_mask |= PORT_IRQ_PHYRDY;
     811                 :          0 :                 writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK);
     812                 :            :         }
     813                 :            : 
     814                 :            :         return 0;
     815                 :            : }
     816                 :            : 
     817                 :            : #ifdef CONFIG_PM
     818                 :          0 : static void ahci_power_down(struct ata_port *ap)
     819                 :            : {
     820                 :          0 :         struct ahci_host_priv *hpriv = ap->host->private_data;
     821         [ #  # ]:          0 :         void __iomem *port_mmio = ahci_port_base(ap);
     822                 :          0 :         u32 cmd, scontrol;
     823                 :            : 
     824         [ #  # ]:          0 :         if (!(hpriv->cap & HOST_CAP_SSS))
     825                 :            :                 return;
     826                 :            : 
     827                 :            :         /* put device into listen mode, first set PxSCTL.DET to 0 */
     828                 :          0 :         scontrol = readl(port_mmio + PORT_SCR_CTL);
     829                 :          0 :         scontrol &= ~0xf;
     830                 :          0 :         writel(scontrol, port_mmio + PORT_SCR_CTL);
     831                 :            : 
     832                 :            :         /* then set PxCMD.SUD to 0 */
     833                 :          0 :         cmd = readl(port_mmio + PORT_CMD) & ~PORT_CMD_ICC_MASK;
     834                 :          0 :         cmd &= ~PORT_CMD_SPIN_UP;
     835                 :          0 :         writel(cmd, port_mmio + PORT_CMD);
     836                 :            : }
     837                 :            : #endif
     838                 :            : 
     839                 :          0 : static void ahci_start_port(struct ata_port *ap)
     840                 :            : {
     841                 :          0 :         struct ahci_host_priv *hpriv = ap->host->private_data;
     842                 :          0 :         struct ahci_port_priv *pp = ap->private_data;
     843                 :          0 :         struct ata_link *link;
     844                 :          0 :         struct ahci_em_priv *emp;
     845                 :          0 :         ssize_t rc;
     846                 :          0 :         int i;
     847                 :            : 
     848                 :            :         /* enable FIS reception */
     849                 :          0 :         ahci_start_fis_rx(ap);
     850                 :            : 
     851                 :            :         /* enable DMA */
     852         [ #  # ]:          0 :         if (!(hpriv->flags & AHCI_HFLAG_DELAY_ENGINE))
     853                 :          0 :                 hpriv->start_engine(ap);
     854                 :            : 
     855                 :            :         /* turn on LEDs */
     856         [ #  # ]:          0 :         if (ap->flags & ATA_FLAG_EM) {
     857         [ #  # ]:          0 :                 ata_for_each_link(link, ap, EDGE) {
     858                 :          0 :                         emp = &pp->em_priv[link->pmp];
     859                 :            : 
     860                 :            :                         /* EM Transmit bit maybe busy during init */
     861         [ #  # ]:          0 :                         for (i = 0; i < EM_MAX_RETRY; i++) {
     862                 :          0 :                                 rc = ap->ops->transmit_led_message(ap,
     863                 :          0 :                                                                emp->led_state,
     864                 :            :                                                                4);
     865                 :            :                                 /*
     866                 :            :                                  * If busy, give a breather but do not
     867                 :            :                                  * release EH ownership by using msleep()
     868                 :            :                                  * instead of ata_msleep().  EM Transmit
     869                 :            :                                  * bit is busy for the whole host and
     870                 :            :                                  * releasing ownership will cause other
     871                 :            :                                  * ports to fail the same way.
     872                 :            :                                  */
     873         [ #  # ]:          0 :                                 if (rc == -EBUSY)
     874                 :          0 :                                         msleep(1);
     875                 :            :                                 else
     876                 :            :                                         break;
     877                 :            :                         }
     878                 :            :                 }
     879                 :            :         }
     880                 :            : 
     881         [ #  # ]:          0 :         if (ap->flags & ATA_FLAG_SW_ACTIVITY)
     882         [ #  # ]:          0 :                 ata_for_each_link(link, ap, EDGE)
     883                 :          0 :                         ahci_init_sw_activity(link);
     884                 :            : 
     885                 :          0 : }
     886                 :            : 
     887                 :          0 : static int ahci_deinit_port(struct ata_port *ap, const char **emsg)
     888                 :            : {
     889                 :          0 :         int rc;
     890                 :          0 :         struct ahci_host_priv *hpriv = ap->host->private_data;
     891                 :            : 
     892                 :            :         /* disable DMA */
     893                 :          0 :         rc = hpriv->stop_engine(ap);
     894         [ #  # ]:          0 :         if (rc) {
     895                 :          0 :                 *emsg = "failed to stop engine";
     896                 :          0 :                 return rc;
     897                 :            :         }
     898                 :            : 
     899                 :            :         /* disable FIS reception */
     900                 :          0 :         rc = ahci_stop_fis_rx(ap);
     901         [ #  # ]:          0 :         if (rc) {
     902                 :          0 :                 *emsg = "failed stop FIS RX";
     903                 :          0 :                 return rc;
     904                 :            :         }
     905                 :            : 
     906                 :            :         return 0;
     907                 :            : }
     908                 :            : 
     909                 :          0 : int ahci_reset_controller(struct ata_host *host)
     910                 :            : {
     911                 :          0 :         struct ahci_host_priv *hpriv = host->private_data;
     912                 :          0 :         void __iomem *mmio = hpriv->mmio;
     913                 :          0 :         u32 tmp;
     914                 :            : 
     915                 :            :         /* we must be in AHCI mode, before using anything
     916                 :            :          * AHCI-specific, such as HOST_RESET.
     917                 :            :          */
     918                 :          0 :         ahci_enable_ahci(mmio);
     919                 :            : 
     920                 :            :         /* global controller reset */
     921         [ #  # ]:          0 :         if (!ahci_skip_host_reset) {
     922                 :          0 :                 tmp = readl(mmio + HOST_CTL);
     923         [ #  # ]:          0 :                 if ((tmp & HOST_RESET) == 0) {
     924                 :          0 :                         writel(tmp | HOST_RESET, mmio + HOST_CTL);
     925                 :          0 :                         readl(mmio + HOST_CTL); /* flush */
     926                 :            :                 }
     927                 :            : 
     928                 :            :                 /*
     929                 :            :                  * to perform host reset, OS should set HOST_RESET
     930                 :            :                  * and poll until this bit is read to be "0".
     931                 :            :                  * reset must complete within 1 second, or
     932                 :            :                  * the hardware should be considered fried.
     933                 :            :                  */
     934                 :          0 :                 tmp = ata_wait_register(NULL, mmio + HOST_CTL, HOST_RESET,
     935                 :            :                                         HOST_RESET, 10, 1000);
     936                 :            : 
     937         [ #  # ]:          0 :                 if (tmp & HOST_RESET) {
     938                 :          0 :                         dev_err(host->dev, "controller reset failed (0x%x)\n",
     939                 :            :                                 tmp);
     940                 :          0 :                         return -EIO;
     941                 :            :                 }
     942                 :            : 
     943                 :            :                 /* turn on AHCI mode */
     944                 :          0 :                 ahci_enable_ahci(mmio);
     945                 :            : 
     946                 :            :                 /* Some registers might be cleared on reset.  Restore
     947                 :            :                  * initial values.
     948                 :            :                  */
     949         [ #  # ]:          0 :                 if (!(hpriv->flags & AHCI_HFLAG_NO_WRITE_TO_RO))
     950                 :          0 :                         ahci_restore_initial_config(host);
     951                 :            :         } else
     952                 :          0 :                 dev_info(host->dev, "skipping global host reset\n");
     953                 :            : 
     954                 :            :         return 0;
     955                 :            : }
     956                 :            : EXPORT_SYMBOL_GPL(ahci_reset_controller);
     957                 :            : 
     958                 :          0 : static void ahci_sw_activity(struct ata_link *link)
     959                 :            : {
     960                 :          0 :         struct ata_port *ap = link->ap;
     961                 :          0 :         struct ahci_port_priv *pp = ap->private_data;
     962                 :          0 :         struct ahci_em_priv *emp = &pp->em_priv[link->pmp];
     963                 :            : 
     964         [ #  # ]:          0 :         if (!(link->flags & ATA_LFLAG_SW_ACTIVITY))
     965                 :            :                 return;
     966                 :            : 
     967                 :          0 :         emp->activity++;
     968         [ #  # ]:          0 :         if (!timer_pending(&emp->timer))
     969                 :          0 :                 mod_timer(&emp->timer, jiffies + msecs_to_jiffies(10));
     970                 :            : }
     971                 :            : 
     972                 :          0 : static void ahci_sw_activity_blink(struct timer_list *t)
     973                 :            : {
     974                 :          0 :         struct ahci_em_priv *emp = from_timer(emp, t, timer);
     975                 :          0 :         struct ata_link *link = emp->link;
     976                 :          0 :         struct ata_port *ap = link->ap;
     977                 :            : 
     978                 :          0 :         unsigned long led_message = emp->led_state;
     979                 :          0 :         u32 activity_led_state;
     980                 :          0 :         unsigned long flags;
     981                 :            : 
     982                 :          0 :         led_message &= EM_MSG_LED_VALUE;
     983                 :          0 :         led_message |= ap->port_no | (link->pmp << 8);
     984                 :            : 
     985                 :            :         /* check to see if we've had activity.  If so,
     986                 :            :          * toggle state of LED and reset timer.  If not,
     987                 :            :          * turn LED to desired idle state.
     988                 :            :          */
     989                 :          0 :         spin_lock_irqsave(ap->lock, flags);
     990         [ #  # ]:          0 :         if (emp->saved_activity != emp->activity) {
     991                 :          0 :                 emp->saved_activity = emp->activity;
     992                 :            :                 /* get the current LED state */
     993                 :          0 :                 activity_led_state = led_message & EM_MSG_LED_VALUE_ON;
     994                 :            : 
     995         [ #  # ]:          0 :                 if (activity_led_state)
     996                 :            :                         activity_led_state = 0;
     997                 :            :                 else
     998                 :          0 :                         activity_led_state = 1;
     999                 :            : 
    1000                 :            :                 /* clear old state */
    1001                 :          0 :                 led_message &= ~EM_MSG_LED_VALUE_ACTIVITY;
    1002                 :            : 
    1003                 :            :                 /* toggle state */
    1004                 :          0 :                 led_message |= (activity_led_state << 16);
    1005                 :          0 :                 mod_timer(&emp->timer, jiffies + msecs_to_jiffies(100));
    1006                 :            :         } else {
    1007                 :            :                 /* switch to idle */
    1008                 :          0 :                 led_message &= ~EM_MSG_LED_VALUE_ACTIVITY;
    1009         [ #  # ]:          0 :                 if (emp->blink_policy == BLINK_OFF)
    1010                 :          0 :                         led_message |= (1 << 16);
    1011                 :            :         }
    1012                 :          0 :         spin_unlock_irqrestore(ap->lock, flags);
    1013                 :          0 :         ap->ops->transmit_led_message(ap, led_message, 4);
    1014                 :          0 : }
    1015                 :            : 
    1016                 :          0 : static void ahci_init_sw_activity(struct ata_link *link)
    1017                 :            : {
    1018                 :          0 :         struct ata_port *ap = link->ap;
    1019                 :          0 :         struct ahci_port_priv *pp = ap->private_data;
    1020                 :          0 :         struct ahci_em_priv *emp = &pp->em_priv[link->pmp];
    1021                 :            : 
    1022                 :            :         /* init activity stats, setup timer */
    1023                 :          0 :         emp->saved_activity = emp->activity = 0;
    1024                 :          0 :         emp->link = link;
    1025                 :          0 :         timer_setup(&emp->timer, ahci_sw_activity_blink, 0);
    1026                 :            : 
    1027                 :            :         /* check our blink policy and set flag for link if it's enabled */
    1028         [ #  # ]:          0 :         if (emp->blink_policy)
    1029                 :          0 :                 link->flags |= ATA_LFLAG_SW_ACTIVITY;
    1030                 :          0 : }
    1031                 :            : 
    1032                 :          0 : int ahci_reset_em(struct ata_host *host)
    1033                 :            : {
    1034                 :          0 :         struct ahci_host_priv *hpriv = host->private_data;
    1035                 :          0 :         void __iomem *mmio = hpriv->mmio;
    1036                 :          0 :         u32 em_ctl;
    1037                 :            : 
    1038                 :          0 :         em_ctl = readl(mmio + HOST_EM_CTL);
    1039         [ #  # ]:          0 :         if ((em_ctl & EM_CTL_TM) || (em_ctl & EM_CTL_RST))
    1040                 :            :                 return -EINVAL;
    1041                 :            : 
    1042                 :          0 :         writel(em_ctl | EM_CTL_RST, mmio + HOST_EM_CTL);
    1043                 :          0 :         return 0;
    1044                 :            : }
    1045                 :            : EXPORT_SYMBOL_GPL(ahci_reset_em);
    1046                 :            : 
    1047                 :          0 : static ssize_t ahci_transmit_led_message(struct ata_port *ap, u32 state,
    1048                 :            :                                         ssize_t size)
    1049                 :            : {
    1050                 :          0 :         struct ahci_host_priv *hpriv = ap->host->private_data;
    1051                 :          0 :         struct ahci_port_priv *pp = ap->private_data;
    1052                 :          0 :         void __iomem *mmio = hpriv->mmio;
    1053                 :          0 :         u32 em_ctl;
    1054                 :          0 :         u32 message[] = {0, 0};
    1055                 :          0 :         unsigned long flags;
    1056                 :          0 :         int pmp;
    1057                 :          0 :         struct ahci_em_priv *emp;
    1058                 :            : 
    1059                 :            :         /* get the slot number from the message */
    1060                 :          0 :         pmp = (state & EM_MSG_LED_PMP_SLOT) >> 8;
    1061         [ #  # ]:          0 :         if (pmp < EM_MAX_SLOTS)
    1062                 :          0 :                 emp = &pp->em_priv[pmp];
    1063                 :            :         else
    1064                 :            :                 return -EINVAL;
    1065                 :            : 
    1066                 :          0 :         ahci_rpm_get_port(ap);
    1067                 :          0 :         spin_lock_irqsave(ap->lock, flags);
    1068                 :            : 
    1069                 :            :         /*
    1070                 :            :          * if we are still busy transmitting a previous message,
    1071                 :            :          * do not allow
    1072                 :            :          */
    1073                 :          0 :         em_ctl = readl(mmio + HOST_EM_CTL);
    1074         [ #  # ]:          0 :         if (em_ctl & EM_CTL_TM) {
    1075                 :          0 :                 spin_unlock_irqrestore(ap->lock, flags);
    1076                 :          0 :                 ahci_rpm_put_port(ap);
    1077                 :          0 :                 return -EBUSY;
    1078                 :            :         }
    1079                 :            : 
    1080         [ #  # ]:          0 :         if (hpriv->em_msg_type & EM_MSG_TYPE_LED) {
    1081                 :            :                 /*
    1082                 :            :                  * create message header - this is all zero except for
    1083                 :            :                  * the message size, which is 4 bytes.
    1084                 :            :                  */
    1085                 :          0 :                 message[0] |= (4 << 8);
    1086                 :            : 
    1087                 :            :                 /* ignore 0:4 of byte zero, fill in port info yourself */
    1088                 :          0 :                 message[1] = ((state & ~EM_MSG_LED_HBA_PORT) | ap->port_no);
    1089                 :            : 
    1090                 :            :                 /* write message to EM_LOC */
    1091                 :          0 :                 writel(message[0], mmio + hpriv->em_loc);
    1092                 :          0 :                 writel(message[1], mmio + hpriv->em_loc+4);
    1093                 :            : 
    1094                 :            :                 /*
    1095                 :            :                  * tell hardware to transmit the message
    1096                 :            :                  */
    1097                 :          0 :                 writel(em_ctl | EM_CTL_TM, mmio + HOST_EM_CTL);
    1098                 :            :         }
    1099                 :            : 
    1100                 :            :         /* save off new led state for port/slot */
    1101                 :          0 :         emp->led_state = state;
    1102                 :            : 
    1103                 :          0 :         spin_unlock_irqrestore(ap->lock, flags);
    1104                 :          0 :         ahci_rpm_put_port(ap);
    1105                 :            : 
    1106                 :          0 :         return size;
    1107                 :            : }
    1108                 :            : 
    1109                 :          0 : static ssize_t ahci_led_show(struct ata_port *ap, char *buf)
    1110                 :            : {
    1111                 :          0 :         struct ahci_port_priv *pp = ap->private_data;
    1112                 :          0 :         struct ata_link *link;
    1113                 :          0 :         struct ahci_em_priv *emp;
    1114                 :          0 :         int rc = 0;
    1115                 :            : 
    1116         [ #  # ]:          0 :         ata_for_each_link(link, ap, EDGE) {
    1117                 :          0 :                 emp = &pp->em_priv[link->pmp];
    1118                 :          0 :                 rc += sprintf(buf, "%lx\n", emp->led_state);
    1119                 :            :         }
    1120                 :          0 :         return rc;
    1121                 :            : }
    1122                 :            : 
    1123                 :          0 : static ssize_t ahci_led_store(struct ata_port *ap, const char *buf,
    1124                 :            :                                 size_t size)
    1125                 :            : {
    1126                 :          0 :         unsigned int state;
    1127                 :          0 :         int pmp;
    1128                 :          0 :         struct ahci_port_priv *pp = ap->private_data;
    1129                 :          0 :         struct ahci_em_priv *emp;
    1130                 :            : 
    1131         [ #  # ]:          0 :         if (kstrtouint(buf, 0, &state) < 0)
    1132                 :            :                 return -EINVAL;
    1133                 :            : 
    1134                 :            :         /* get the slot number from the message */
    1135                 :          0 :         pmp = (state & EM_MSG_LED_PMP_SLOT) >> 8;
    1136         [ #  # ]:          0 :         if (pmp < EM_MAX_SLOTS) {
    1137                 :          0 :                 pmp = array_index_nospec(pmp, EM_MAX_SLOTS);
    1138                 :          0 :                 emp = &pp->em_priv[pmp];
    1139                 :            :         } else {
    1140                 :            :                 return -EINVAL;
    1141                 :            :         }
    1142                 :            : 
    1143                 :            :         /* mask off the activity bits if we are in sw_activity
    1144                 :            :          * mode, user should turn off sw_activity before setting
    1145                 :            :          * activity led through em_message
    1146                 :            :          */
    1147         [ #  # ]:          0 :         if (emp->blink_policy)
    1148                 :          0 :                 state &= ~EM_MSG_LED_VALUE_ACTIVITY;
    1149                 :            : 
    1150                 :          0 :         return ap->ops->transmit_led_message(ap, state, size);
    1151                 :            : }
    1152                 :            : 
    1153                 :          0 : static ssize_t ahci_activity_store(struct ata_device *dev, enum sw_activity val)
    1154                 :            : {
    1155                 :          0 :         struct ata_link *link = dev->link;
    1156                 :          0 :         struct ata_port *ap = link->ap;
    1157                 :          0 :         struct ahci_port_priv *pp = ap->private_data;
    1158                 :          0 :         struct ahci_em_priv *emp = &pp->em_priv[link->pmp];
    1159                 :          0 :         u32 port_led_state = emp->led_state;
    1160                 :            : 
    1161                 :            :         /* save the desired Activity LED behavior */
    1162         [ #  # ]:          0 :         if (val == OFF) {
    1163                 :            :                 /* clear LFLAG */
    1164                 :          0 :                 link->flags &= ~(ATA_LFLAG_SW_ACTIVITY);
    1165                 :            : 
    1166                 :            :                 /* set the LED to OFF */
    1167                 :          0 :                 port_led_state &= EM_MSG_LED_VALUE_OFF;
    1168                 :          0 :                 port_led_state |= (ap->port_no | (link->pmp << 8));
    1169                 :          0 :                 ap->ops->transmit_led_message(ap, port_led_state, 4);
    1170                 :            :         } else {
    1171                 :          0 :                 link->flags |= ATA_LFLAG_SW_ACTIVITY;
    1172         [ #  # ]:          0 :                 if (val == BLINK_OFF) {
    1173                 :            :                         /* set LED to ON for idle */
    1174                 :          0 :                         port_led_state &= EM_MSG_LED_VALUE_OFF;
    1175                 :          0 :                         port_led_state |= (ap->port_no | (link->pmp << 8));
    1176                 :          0 :                         port_led_state |= EM_MSG_LED_VALUE_ON; /* check this */
    1177                 :          0 :                         ap->ops->transmit_led_message(ap, port_led_state, 4);
    1178                 :            :                 }
    1179                 :            :         }
    1180                 :          0 :         emp->blink_policy = val;
    1181                 :          0 :         return 0;
    1182                 :            : }
    1183                 :            : 
    1184                 :          0 : static ssize_t ahci_activity_show(struct ata_device *dev, char *buf)
    1185                 :            : {
    1186                 :          0 :         struct ata_link *link = dev->link;
    1187                 :          0 :         struct ata_port *ap = link->ap;
    1188                 :          0 :         struct ahci_port_priv *pp = ap->private_data;
    1189                 :          0 :         struct ahci_em_priv *emp = &pp->em_priv[link->pmp];
    1190                 :            : 
    1191                 :            :         /* display the saved value of activity behavior for this
    1192                 :            :          * disk.
    1193                 :            :          */
    1194                 :          0 :         return sprintf(buf, "%d\n", emp->blink_policy);
    1195                 :            : }
    1196                 :            : 
    1197                 :          0 : static void ahci_port_init(struct device *dev, struct ata_port *ap,
    1198                 :            :                            int port_no, void __iomem *mmio,
    1199                 :            :                            void __iomem *port_mmio)
    1200                 :            : {
    1201                 :          0 :         struct ahci_host_priv *hpriv = ap->host->private_data;
    1202                 :          0 :         const char *emsg = NULL;
    1203                 :          0 :         int rc;
    1204                 :          0 :         u32 tmp;
    1205                 :            : 
    1206                 :            :         /* make sure port is not active */
    1207                 :          0 :         rc = ahci_deinit_port(ap, &emsg);
    1208         [ #  # ]:          0 :         if (rc)
    1209                 :          0 :                 dev_warn(dev, "%s (%d)\n", emsg, rc);
    1210                 :            : 
    1211                 :            :         /* clear SError */
    1212                 :          0 :         tmp = readl(port_mmio + PORT_SCR_ERR);
    1213                 :          0 :         VPRINTK("PORT_SCR_ERR 0x%x\n", tmp);
    1214                 :          0 :         writel(tmp, port_mmio + PORT_SCR_ERR);
    1215                 :            : 
    1216                 :            :         /* clear port IRQ */
    1217                 :          0 :         tmp = readl(port_mmio + PORT_IRQ_STAT);
    1218                 :          0 :         VPRINTK("PORT_IRQ_STAT 0x%x\n", tmp);
    1219         [ #  # ]:          0 :         if (tmp)
    1220                 :          0 :                 writel(tmp, port_mmio + PORT_IRQ_STAT);
    1221                 :            : 
    1222                 :          0 :         writel(1 << port_no, mmio + HOST_IRQ_STAT);
    1223                 :            : 
    1224                 :            :         /* mark esata ports */
    1225                 :          0 :         tmp = readl(port_mmio + PORT_CMD);
    1226   [ #  #  #  # ]:          0 :         if ((tmp & PORT_CMD_ESP) && (hpriv->cap & HOST_CAP_SXS))
    1227                 :          0 :                 ap->pflags |= ATA_PFLAG_EXTERNAL;
    1228                 :          0 : }
    1229                 :            : 
    1230                 :          0 : void ahci_init_controller(struct ata_host *host)
    1231                 :            : {
    1232                 :          0 :         struct ahci_host_priv *hpriv = host->private_data;
    1233                 :          0 :         void __iomem *mmio = hpriv->mmio;
    1234                 :          0 :         int i;
    1235                 :          0 :         void __iomem *port_mmio;
    1236                 :          0 :         u32 tmp;
    1237                 :            : 
    1238         [ #  # ]:          0 :         for (i = 0; i < host->n_ports; i++) {
    1239                 :          0 :                 struct ata_port *ap = host->ports[i];
    1240                 :            : 
    1241         [ #  # ]:          0 :                 port_mmio = ahci_port_base(ap);
    1242         [ #  # ]:          0 :                 if (ata_port_is_dummy(ap))
    1243                 :          0 :                         continue;
    1244                 :            : 
    1245                 :          0 :                 ahci_port_init(host->dev, ap, i, mmio, port_mmio);
    1246                 :            :         }
    1247                 :            : 
    1248                 :          0 :         tmp = readl(mmio + HOST_CTL);
    1249                 :          0 :         VPRINTK("HOST_CTL 0x%x\n", tmp);
    1250                 :          0 :         writel(tmp | HOST_IRQ_EN, mmio + HOST_CTL);
    1251                 :          0 :         tmp = readl(mmio + HOST_CTL);
    1252                 :          0 :         VPRINTK("HOST_CTL 0x%x\n", tmp);
    1253                 :          0 : }
    1254                 :            : EXPORT_SYMBOL_GPL(ahci_init_controller);
    1255                 :            : 
    1256                 :          0 : static void ahci_dev_config(struct ata_device *dev)
    1257                 :            : {
    1258                 :          0 :         struct ahci_host_priv *hpriv = dev->link->ap->host->private_data;
    1259                 :            : 
    1260         [ #  # ]:          0 :         if (hpriv->flags & AHCI_HFLAG_SECT255) {
    1261                 :          0 :                 dev->max_sectors = 255;
    1262                 :          0 :                 ata_dev_info(dev,
    1263                 :            :                              "SB600 AHCI: limiting to 255 sectors per cmd\n");
    1264                 :            :         }
    1265                 :          0 : }
    1266                 :            : 
    1267                 :          0 : unsigned int ahci_dev_classify(struct ata_port *ap)
    1268                 :            : {
    1269                 :          0 :         void __iomem *port_mmio = ahci_port_base(ap);
    1270                 :          0 :         struct ata_taskfile tf;
    1271                 :          0 :         u32 tmp;
    1272                 :            : 
    1273                 :          0 :         tmp = readl(port_mmio + PORT_SIG);
    1274                 :          0 :         tf.lbah         = (tmp >> 24)     & 0xff;
    1275                 :          0 :         tf.lbam         = (tmp >> 16)     & 0xff;
    1276                 :          0 :         tf.lbal         = (tmp >> 8)      & 0xff;
    1277                 :          0 :         tf.nsect        = (tmp)         & 0xff;
    1278                 :            : 
    1279                 :          0 :         return ata_dev_classify(&tf);
    1280                 :            : }
    1281                 :            : EXPORT_SYMBOL_GPL(ahci_dev_classify);
    1282                 :            : 
    1283                 :          0 : void ahci_fill_cmd_slot(struct ahci_port_priv *pp, unsigned int tag,
    1284                 :            :                         u32 opts)
    1285                 :            : {
    1286                 :          0 :         dma_addr_t cmd_tbl_dma;
    1287                 :            : 
    1288                 :          0 :         cmd_tbl_dma = pp->cmd_tbl_dma + tag * AHCI_CMD_TBL_SZ;
    1289                 :            : 
    1290                 :          0 :         pp->cmd_slot[tag].opts = cpu_to_le32(opts);
    1291                 :          0 :         pp->cmd_slot[tag].status = 0;
    1292                 :          0 :         pp->cmd_slot[tag].tbl_addr = cpu_to_le32(cmd_tbl_dma & 0xffffffff);
    1293                 :          0 :         pp->cmd_slot[tag].tbl_addr_hi = cpu_to_le32((cmd_tbl_dma >> 16) >> 16);
    1294                 :          0 : }
    1295                 :            : EXPORT_SYMBOL_GPL(ahci_fill_cmd_slot);
    1296                 :            : 
    1297                 :          0 : int ahci_kick_engine(struct ata_port *ap)
    1298                 :            : {
    1299                 :          0 :         void __iomem *port_mmio = ahci_port_base(ap);
    1300                 :          0 :         struct ahci_host_priv *hpriv = ap->host->private_data;
    1301                 :          0 :         u8 status = readl(port_mmio + PORT_TFDATA) & 0xFF;
    1302                 :          0 :         u32 tmp;
    1303                 :          0 :         int busy, rc;
    1304                 :            : 
    1305                 :            :         /* stop engine */
    1306                 :          0 :         rc = hpriv->stop_engine(ap);
    1307         [ #  # ]:          0 :         if (rc)
    1308                 :          0 :                 goto out_restart;
    1309                 :            : 
    1310                 :            :         /* need to do CLO?
    1311                 :            :          * always do CLO if PMP is attached (AHCI-1.3 9.2)
    1312                 :            :          */
    1313                 :          0 :         busy = status & (ATA_BUSY | ATA_DRQ);
    1314   [ #  #  #  # ]:          0 :         if (!busy && !sata_pmp_attached(ap)) {
    1315                 :          0 :                 rc = 0;
    1316                 :          0 :                 goto out_restart;
    1317                 :            :         }
    1318                 :            : 
    1319         [ #  # ]:          0 :         if (!(hpriv->cap & HOST_CAP_CLO)) {
    1320                 :          0 :                 rc = -EOPNOTSUPP;
    1321                 :          0 :                 goto out_restart;
    1322                 :            :         }
    1323                 :            : 
    1324                 :            :         /* perform CLO */
    1325                 :          0 :         tmp = readl(port_mmio + PORT_CMD);
    1326                 :          0 :         tmp |= PORT_CMD_CLO;
    1327                 :          0 :         writel(tmp, port_mmio + PORT_CMD);
    1328                 :            : 
    1329                 :          0 :         rc = 0;
    1330                 :          0 :         tmp = ata_wait_register(ap, port_mmio + PORT_CMD,
    1331                 :            :                                 PORT_CMD_CLO, PORT_CMD_CLO, 1, 500);
    1332         [ #  # ]:          0 :         if (tmp & PORT_CMD_CLO)
    1333                 :          0 :                 rc = -EIO;
    1334                 :            : 
    1335                 :            :         /* restart engine */
    1336                 :          0 :  out_restart:
    1337                 :          0 :         hpriv->start_engine(ap);
    1338                 :          0 :         return rc;
    1339                 :            : }
    1340                 :            : EXPORT_SYMBOL_GPL(ahci_kick_engine);
    1341                 :            : 
    1342                 :          0 : static int ahci_exec_polled_cmd(struct ata_port *ap, int pmp,
    1343                 :            :                                 struct ata_taskfile *tf, int is_cmd, u16 flags,
    1344                 :            :                                 unsigned long timeout_msec)
    1345                 :            : {
    1346                 :          0 :         const u32 cmd_fis_len = 5; /* five dwords */
    1347                 :          0 :         struct ahci_port_priv *pp = ap->private_data;
    1348                 :          0 :         void __iomem *port_mmio = ahci_port_base(ap);
    1349                 :          0 :         u8 *fis = pp->cmd_tbl;
    1350                 :          0 :         u32 tmp;
    1351                 :            : 
    1352                 :            :         /* prep the command */
    1353                 :          0 :         ata_tf_to_fis(tf, pmp, is_cmd, fis);
    1354                 :          0 :         ahci_fill_cmd_slot(pp, 0, cmd_fis_len | flags | (pmp << 12));
    1355                 :            : 
    1356                 :            :         /* set port value for softreset of Port Multiplier */
    1357   [ #  #  #  # ]:          0 :         if (pp->fbs_enabled && pp->fbs_last_dev != pmp) {
    1358                 :          0 :                 tmp = readl(port_mmio + PORT_FBS);
    1359                 :          0 :                 tmp &= ~(PORT_FBS_DEV_MASK | PORT_FBS_DEC);
    1360                 :          0 :                 tmp |= pmp << PORT_FBS_DEV_OFFSET;
    1361                 :          0 :                 writel(tmp, port_mmio + PORT_FBS);
    1362                 :          0 :                 pp->fbs_last_dev = pmp;
    1363                 :            :         }
    1364                 :            : 
    1365                 :            :         /* issue & wait */
    1366                 :          0 :         writel(1, port_mmio + PORT_CMD_ISSUE);
    1367                 :            : 
    1368         [ #  # ]:          0 :         if (timeout_msec) {
    1369                 :          0 :                 tmp = ata_wait_register(ap, port_mmio + PORT_CMD_ISSUE,
    1370                 :            :                                         0x1, 0x1, 1, timeout_msec);
    1371         [ #  # ]:          0 :                 if (tmp & 0x1) {
    1372                 :          0 :                         ahci_kick_engine(ap);
    1373                 :          0 :                         return -EBUSY;
    1374                 :            :                 }
    1375                 :            :         } else
    1376                 :          0 :                 readl(port_mmio + PORT_CMD_ISSUE);      /* flush */
    1377                 :            : 
    1378                 :            :         return 0;
    1379                 :            : }
    1380                 :            : 
    1381                 :          0 : int ahci_do_softreset(struct ata_link *link, unsigned int *class,
    1382                 :            :                       int pmp, unsigned long deadline,
    1383                 :            :                       int (*check_ready)(struct ata_link *link))
    1384                 :            : {
    1385                 :          0 :         struct ata_port *ap = link->ap;
    1386                 :          0 :         struct ahci_host_priv *hpriv = ap->host->private_data;
    1387                 :          0 :         struct ahci_port_priv *pp = ap->private_data;
    1388                 :          0 :         const char *reason = NULL;
    1389                 :          0 :         unsigned long now, msecs;
    1390                 :          0 :         struct ata_taskfile tf;
    1391                 :          0 :         bool fbs_disabled = false;
    1392                 :          0 :         int rc;
    1393                 :            : 
    1394                 :          0 :         DPRINTK("ENTER\n");
    1395                 :            : 
    1396                 :            :         /* prepare for SRST (AHCI-1.1 10.4.1) */
    1397                 :          0 :         rc = ahci_kick_engine(ap);
    1398         [ #  # ]:          0 :         if (rc && rc != -EOPNOTSUPP)
    1399                 :          0 :                 ata_link_warn(link, "failed to reset engine (errno=%d)\n", rc);
    1400                 :            : 
    1401                 :            :         /*
    1402                 :            :          * According to AHCI-1.2 9.3.9: if FBS is enable, software shall
    1403                 :            :          * clear PxFBS.EN to '0' prior to issuing software reset to devices
    1404                 :            :          * that is attached to port multiplier.
    1405                 :            :          */
    1406   [ #  #  #  #  :          0 :         if (!ata_is_host_link(link) && pp->fbs_enabled) {
                   #  # ]
    1407                 :          0 :                 ahci_disable_fbs(ap);
    1408                 :          0 :                 fbs_disabled = true;
    1409                 :            :         }
    1410                 :            : 
    1411         [ #  # ]:          0 :         ata_tf_init(link->device, &tf);
    1412                 :            : 
    1413                 :            :         /* issue the first H2D Register FIS */
    1414                 :          0 :         msecs = 0;
    1415                 :          0 :         now = jiffies;
    1416         [ #  # ]:          0 :         if (time_after(deadline, now))
    1417                 :          0 :                 msecs = jiffies_to_msecs(deadline - now);
    1418                 :            : 
    1419                 :          0 :         tf.ctl |= ATA_SRST;
    1420         [ #  # ]:          0 :         if (ahci_exec_polled_cmd(ap, pmp, &tf, 0,
    1421                 :            :                                  AHCI_CMD_RESET | AHCI_CMD_CLR_BUSY, msecs)) {
    1422                 :          0 :                 rc = -EIO;
    1423                 :          0 :                 reason = "1st FIS failed";
    1424                 :          0 :                 goto fail;
    1425                 :            :         }
    1426                 :            : 
    1427                 :            :         /* spec says at least 5us, but be generous and sleep for 1ms */
    1428                 :          0 :         ata_msleep(ap, 1);
    1429                 :            : 
    1430                 :            :         /* issue the second H2D Register FIS */
    1431                 :          0 :         tf.ctl &= ~ATA_SRST;
    1432                 :          0 :         ahci_exec_polled_cmd(ap, pmp, &tf, 0, 0, 0);
    1433                 :            : 
    1434                 :            :         /* wait for link to become ready */
    1435                 :          0 :         rc = ata_wait_after_reset(link, deadline, check_ready);
    1436   [ #  #  #  # ]:          0 :         if (rc == -EBUSY && hpriv->flags & AHCI_HFLAG_SRST_TOUT_IS_OFFLINE) {
    1437                 :            :                 /*
    1438                 :            :                  * Workaround for cases where link online status can't
    1439                 :            :                  * be trusted.  Treat device readiness timeout as link
    1440                 :            :                  * offline.
    1441                 :            :                  */
    1442                 :          0 :                 ata_link_info(link, "device not ready, treating as offline\n");
    1443                 :          0 :                 *class = ATA_DEV_NONE;
    1444         [ #  # ]:          0 :         } else if (rc) {
    1445                 :            :                 /* link occupied, -ENODEV too is an error */
    1446                 :          0 :                 reason = "device not ready";
    1447                 :          0 :                 goto fail;
    1448                 :            :         } else
    1449                 :          0 :                 *class = ahci_dev_classify(ap);
    1450                 :            : 
    1451                 :            :         /* re-enable FBS if disabled before */
    1452         [ #  # ]:          0 :         if (fbs_disabled)
    1453                 :          0 :                 ahci_enable_fbs(ap);
    1454                 :            : 
    1455                 :            :         DPRINTK("EXIT, class=%u\n", *class);
    1456                 :            :         return 0;
    1457                 :            : 
    1458                 :          0 :  fail:
    1459                 :          0 :         ata_link_err(link, "softreset failed (%s)\n", reason);
    1460                 :          0 :         return rc;
    1461                 :            : }
    1462                 :            : 
    1463                 :          0 : int ahci_check_ready(struct ata_link *link)
    1464                 :            : {
    1465                 :          0 :         void __iomem *port_mmio = ahci_port_base(link->ap);
    1466                 :          0 :         u8 status = readl(port_mmio + PORT_TFDATA) & 0xFF;
    1467                 :            : 
    1468         [ #  # ]:          0 :         return ata_check_ready(status);
    1469                 :            : }
    1470                 :            : EXPORT_SYMBOL_GPL(ahci_check_ready);
    1471                 :            : 
    1472                 :          0 : static int ahci_softreset(struct ata_link *link, unsigned int *class,
    1473                 :            :                           unsigned long deadline)
    1474                 :            : {
    1475         [ #  # ]:          0 :         int pmp = sata_srst_pmp(link);
    1476                 :            : 
    1477                 :          0 :         DPRINTK("ENTER\n");
    1478                 :            : 
    1479                 :          0 :         return ahci_do_softreset(link, class, pmp, deadline, ahci_check_ready);
    1480                 :            : }
    1481                 :            : EXPORT_SYMBOL_GPL(ahci_do_softreset);
    1482                 :            : 
    1483                 :          0 : static int ahci_bad_pmp_check_ready(struct ata_link *link)
    1484                 :            : {
    1485                 :          0 :         void __iomem *port_mmio = ahci_port_base(link->ap);
    1486                 :          0 :         u8 status = readl(port_mmio + PORT_TFDATA) & 0xFF;
    1487                 :          0 :         u32 irq_status = readl(port_mmio + PORT_IRQ_STAT);
    1488                 :            : 
    1489                 :            :         /*
    1490                 :            :          * There is no need to check TFDATA if BAD PMP is found due to HW bug,
    1491                 :            :          * which can save timeout delay.
    1492                 :            :          */
    1493         [ #  # ]:          0 :         if (irq_status & PORT_IRQ_BAD_PMP)
    1494                 :            :                 return -EIO;
    1495                 :            : 
    1496         [ #  # ]:          0 :         return ata_check_ready(status);
    1497                 :            : }
    1498                 :            : 
    1499                 :          0 : static int ahci_pmp_retry_softreset(struct ata_link *link, unsigned int *class,
    1500                 :            :                                     unsigned long deadline)
    1501                 :            : {
    1502                 :          0 :         struct ata_port *ap = link->ap;
    1503         [ #  # ]:          0 :         void __iomem *port_mmio = ahci_port_base(ap);
    1504         [ #  # ]:          0 :         int pmp = sata_srst_pmp(link);
    1505                 :          0 :         int rc;
    1506                 :          0 :         u32 irq_sts;
    1507                 :            : 
    1508                 :          0 :         DPRINTK("ENTER\n");
    1509                 :            : 
    1510                 :          0 :         rc = ahci_do_softreset(link, class, pmp, deadline,
    1511                 :            :                                ahci_bad_pmp_check_ready);
    1512                 :            : 
    1513                 :            :         /*
    1514                 :            :          * Soft reset fails with IPMS set when PMP is enabled but
    1515                 :            :          * SATA HDD/ODD is connected to SATA port, do soft reset
    1516                 :            :          * again to port 0.
    1517                 :            :          */
    1518         [ #  # ]:          0 :         if (rc == -EIO) {
    1519                 :          0 :                 irq_sts = readl(port_mmio + PORT_IRQ_STAT);
    1520         [ #  # ]:          0 :                 if (irq_sts & PORT_IRQ_BAD_PMP) {
    1521                 :          0 :                         ata_link_warn(link,
    1522                 :            :                                         "applying PMP SRST workaround "
    1523                 :            :                                         "and retrying\n");
    1524                 :          0 :                         rc = ahci_do_softreset(link, class, 0, deadline,
    1525                 :            :                                                ahci_check_ready);
    1526                 :            :                 }
    1527                 :            :         }
    1528                 :            : 
    1529                 :          0 :         return rc;
    1530                 :            : }
    1531                 :            : 
    1532                 :          0 : int ahci_do_hardreset(struct ata_link *link, unsigned int *class,
    1533                 :            :                       unsigned long deadline, bool *online)
    1534                 :            : {
    1535         [ #  # ]:          0 :         const unsigned long *timing = sata_ehc_deb_timing(&link->eh_context);
    1536                 :          0 :         struct ata_port *ap = link->ap;
    1537                 :          0 :         struct ahci_port_priv *pp = ap->private_data;
    1538                 :          0 :         struct ahci_host_priv *hpriv = ap->host->private_data;
    1539                 :          0 :         u8 *d2h_fis = pp->rx_fis + RX_FIS_D2H_REG;
    1540                 :          0 :         struct ata_taskfile tf;
    1541                 :          0 :         int rc;
    1542                 :            : 
    1543                 :          0 :         DPRINTK("ENTER\n");
    1544                 :            : 
    1545                 :          0 :         hpriv->stop_engine(ap);
    1546                 :            : 
    1547                 :            :         /* clear D2H reception area to properly wait for D2H FIS */
    1548         [ #  # ]:          0 :         ata_tf_init(link->device, &tf);
    1549                 :          0 :         tf.command = ATA_BUSY;
    1550                 :          0 :         ata_tf_to_fis(&tf, 0, 0, d2h_fis);
    1551                 :            : 
    1552                 :          0 :         rc = sata_link_hardreset(link, timing, deadline, online,
    1553                 :            :                                  ahci_check_ready);
    1554                 :            : 
    1555                 :          0 :         hpriv->start_engine(ap);
    1556                 :            : 
    1557         [ #  # ]:          0 :         if (*online)
    1558                 :          0 :                 *class = ahci_dev_classify(ap);
    1559                 :            : 
    1560                 :          0 :         DPRINTK("EXIT, rc=%d, class=%u\n", rc, *class);
    1561                 :          0 :         return rc;
    1562                 :            : }
    1563                 :            : EXPORT_SYMBOL_GPL(ahci_do_hardreset);
    1564                 :            : 
    1565                 :          0 : static int ahci_hardreset(struct ata_link *link, unsigned int *class,
    1566                 :            :                           unsigned long deadline)
    1567                 :            : {
    1568                 :          0 :         bool online;
    1569                 :            : 
    1570                 :          0 :         return ahci_do_hardreset(link, class, deadline, &online);
    1571                 :            : }
    1572                 :            : 
    1573                 :          0 : static void ahci_postreset(struct ata_link *link, unsigned int *class)
    1574                 :            : {
    1575                 :          0 :         struct ata_port *ap = link->ap;
    1576                 :          0 :         void __iomem *port_mmio = ahci_port_base(ap);
    1577                 :          0 :         u32 new_tmp, tmp;
    1578                 :            : 
    1579                 :          0 :         ata_std_postreset(link, class);
    1580                 :            : 
    1581                 :            :         /* Make sure port's ATAPI bit is set appropriately */
    1582                 :          0 :         new_tmp = tmp = readl(port_mmio + PORT_CMD);
    1583         [ #  # ]:          0 :         if (*class == ATA_DEV_ATAPI)
    1584                 :          0 :                 new_tmp |= PORT_CMD_ATAPI;
    1585                 :            :         else
    1586                 :          0 :                 new_tmp &= ~PORT_CMD_ATAPI;
    1587         [ #  # ]:          0 :         if (new_tmp != tmp) {
    1588                 :          0 :                 writel(new_tmp, port_mmio + PORT_CMD);
    1589                 :          0 :                 readl(port_mmio + PORT_CMD); /* flush */
    1590                 :            :         }
    1591                 :          0 : }
    1592                 :            : 
    1593                 :            : static unsigned int ahci_fill_sg(struct ata_queued_cmd *qc, void *cmd_tbl)
    1594                 :            : {
    1595                 :            :         struct scatterlist *sg;
    1596                 :            :         struct ahci_sg *ahci_sg = cmd_tbl + AHCI_CMD_TBL_HDR_SZ;
    1597                 :            :         unsigned int si;
    1598                 :            : 
    1599                 :            :         VPRINTK("ENTER\n");
    1600                 :            : 
    1601                 :            :         /*
    1602                 :            :          * Next, the S/G list.
    1603                 :            :          */
    1604                 :            :         for_each_sg(qc->sg, sg, qc->n_elem, si) {
    1605                 :            :                 dma_addr_t addr = sg_dma_address(sg);
    1606                 :            :                 u32 sg_len = sg_dma_len(sg);
    1607                 :            : 
    1608                 :            :                 ahci_sg[si].addr = cpu_to_le32(addr & 0xffffffff);
    1609                 :            :                 ahci_sg[si].addr_hi = cpu_to_le32((addr >> 16) >> 16);
    1610                 :            :                 ahci_sg[si].flags_size = cpu_to_le32(sg_len - 1);
    1611                 :            :         }
    1612                 :            : 
    1613                 :            :         return si;
    1614                 :            : }
    1615                 :            : 
    1616                 :          0 : static int ahci_pmp_qc_defer(struct ata_queued_cmd *qc)
    1617                 :            : {
    1618                 :          0 :         struct ata_port *ap = qc->ap;
    1619                 :          0 :         struct ahci_port_priv *pp = ap->private_data;
    1620                 :            : 
    1621   [ #  #  #  # ]:          0 :         if (!sata_pmp_attached(ap) || pp->fbs_enabled)
    1622                 :          0 :                 return ata_std_qc_defer(qc);
    1623                 :            :         else
    1624                 :          0 :                 return sata_pmp_qc_defer_cmd_switch(qc);
    1625                 :            : }
    1626                 :            : 
    1627                 :          0 : static enum ata_completion_errors ahci_qc_prep(struct ata_queued_cmd *qc)
    1628                 :            : {
    1629                 :          0 :         struct ata_port *ap = qc->ap;
    1630                 :          0 :         struct ahci_port_priv *pp = ap->private_data;
    1631                 :          0 :         int is_atapi = ata_is_atapi(qc->tf.protocol);
    1632                 :          0 :         void *cmd_tbl;
    1633                 :          0 :         u32 opts;
    1634                 :          0 :         const u32 cmd_fis_len = 5; /* five dwords */
    1635                 :          0 :         unsigned int n_elem;
    1636                 :            : 
    1637                 :            :         /*
    1638                 :            :          * Fill in command table information.  First, the header,
    1639                 :            :          * a SATA Register - Host to Device command FIS.
    1640                 :            :          */
    1641                 :          0 :         cmd_tbl = pp->cmd_tbl + qc->hw_tag * AHCI_CMD_TBL_SZ;
    1642                 :            : 
    1643                 :          0 :         ata_tf_to_fis(&qc->tf, qc->dev->link->pmp, 1, cmd_tbl);
    1644         [ #  # ]:          0 :         if (is_atapi) {
    1645                 :          0 :                 memset(cmd_tbl + AHCI_CMD_TBL_CDB, 0, 32);
    1646                 :          0 :                 memcpy(cmd_tbl + AHCI_CMD_TBL_CDB, qc->cdb, qc->dev->cdb_len);
    1647                 :            :         }
    1648                 :            : 
    1649                 :          0 :         n_elem = 0;
    1650         [ #  # ]:          0 :         if (qc->flags & ATA_QCFLAG_DMAMAP)
    1651                 :          0 :                 n_elem = ahci_fill_sg(qc, cmd_tbl);
    1652                 :            : 
    1653                 :            :         /*
    1654                 :            :          * Fill in command slot information.
    1655                 :            :          */
    1656                 :          0 :         opts = cmd_fis_len | n_elem << 16 | (qc->dev->link->pmp << 12);
    1657         [ #  # ]:          0 :         if (qc->tf.flags & ATA_TFLAG_WRITE)
    1658                 :          0 :                 opts |= AHCI_CMD_WRITE;
    1659         [ #  # ]:          0 :         if (is_atapi)
    1660                 :          0 :                 opts |= AHCI_CMD_ATAPI | AHCI_CMD_PREFETCH;
    1661                 :            : 
    1662                 :          0 :         ahci_fill_cmd_slot(pp, qc->hw_tag, opts);
    1663                 :            : 
    1664                 :          0 :         return AC_ERR_OK;
    1665                 :            : }
    1666                 :            : 
    1667                 :          0 : static void ahci_fbs_dec_intr(struct ata_port *ap)
    1668                 :            : {
    1669                 :          0 :         struct ahci_port_priv *pp = ap->private_data;
    1670                 :          0 :         void __iomem *port_mmio = ahci_port_base(ap);
    1671                 :          0 :         u32 fbs = readl(port_mmio + PORT_FBS);
    1672                 :          0 :         int retries = 3;
    1673                 :            : 
    1674                 :          0 :         DPRINTK("ENTER\n");
    1675         [ #  # ]:          0 :         BUG_ON(!pp->fbs_enabled);
    1676                 :            : 
    1677                 :            :         /* time to wait for DEC is not specified by AHCI spec,
    1678                 :            :          * add a retry loop for safety.
    1679                 :            :          */
    1680                 :          0 :         writel(fbs | PORT_FBS_DEC, port_mmio + PORT_FBS);
    1681                 :          0 :         fbs = readl(port_mmio + PORT_FBS);
    1682   [ #  #  #  # ]:          0 :         while ((fbs & PORT_FBS_DEC) && retries--) {
    1683                 :          0 :                 udelay(1);
    1684                 :          0 :                 fbs = readl(port_mmio + PORT_FBS);
    1685                 :            :         }
    1686                 :            : 
    1687         [ #  # ]:          0 :         if (fbs & PORT_FBS_DEC)
    1688                 :          0 :                 dev_err(ap->host->dev, "failed to clear device error\n");
    1689                 :          0 : }
    1690                 :            : 
    1691                 :          0 : static void ahci_error_intr(struct ata_port *ap, u32 irq_stat)
    1692                 :            : {
    1693                 :          0 :         struct ahci_host_priv *hpriv = ap->host->private_data;
    1694                 :          0 :         struct ahci_port_priv *pp = ap->private_data;
    1695                 :          0 :         struct ata_eh_info *host_ehi = &ap->link.eh_info;
    1696                 :          0 :         struct ata_link *link = NULL;
    1697                 :          0 :         struct ata_queued_cmd *active_qc;
    1698                 :          0 :         struct ata_eh_info *active_ehi;
    1699                 :          0 :         bool fbs_need_dec = false;
    1700                 :          0 :         u32 serror;
    1701                 :            : 
    1702                 :            :         /* determine active link with error */
    1703         [ #  # ]:          0 :         if (pp->fbs_enabled) {
    1704                 :          0 :                 void __iomem *port_mmio = ahci_port_base(ap);
    1705                 :          0 :                 u32 fbs = readl(port_mmio + PORT_FBS);
    1706                 :          0 :                 int pmp = fbs >> PORT_FBS_DWE_OFFSET;
    1707                 :            : 
    1708   [ #  #  #  # ]:          0 :                 if ((fbs & PORT_FBS_SDE) && (pmp < ap->nr_pmp_links)) {
    1709                 :          0 :                         link = &ap->pmp_link[pmp];
    1710                 :          0 :                         fbs_need_dec = true;
    1711                 :            :                 }
    1712                 :            : 
    1713                 :            :         } else
    1714         [ #  # ]:          0 :                 ata_for_each_link(link, ap, EDGE)
    1715         [ #  # ]:          0 :                         if (ata_link_active(link))
    1716                 :            :                                 break;
    1717                 :            : 
    1718         [ #  # ]:          0 :         if (!link)
    1719                 :          0 :                 link = &ap->link;
    1720                 :            : 
    1721         [ #  # ]:          0 :         active_qc = ata_qc_from_tag(ap, link->active_tag);
    1722                 :          0 :         active_ehi = &link->eh_info;
    1723                 :            : 
    1724                 :            :         /* record irq stat */
    1725                 :          0 :         ata_ehi_clear_desc(host_ehi);
    1726                 :          0 :         ata_ehi_push_desc(host_ehi, "irq_stat 0x%08x", irq_stat);
    1727                 :            : 
    1728                 :            :         /* AHCI needs SError cleared; otherwise, it might lock up */
    1729                 :          0 :         ahci_scr_read(&ap->link, SCR_ERROR, &serror);
    1730                 :          0 :         ahci_scr_write(&ap->link, SCR_ERROR, serror);
    1731                 :          0 :         host_ehi->serror |= serror;
    1732                 :            : 
    1733                 :            :         /* some controllers set IRQ_IF_ERR on device errors, ignore it */
    1734         [ #  # ]:          0 :         if (hpriv->flags & AHCI_HFLAG_IGN_IRQ_IF_ERR)
    1735                 :          0 :                 irq_stat &= ~PORT_IRQ_IF_ERR;
    1736                 :            : 
    1737         [ #  # ]:          0 :         if (irq_stat & PORT_IRQ_TF_ERR) {
    1738                 :            :                 /* If qc is active, charge it; otherwise, the active
    1739                 :            :                  * link.  There's no active qc on NCQ errors.  It will
    1740                 :            :                  * be determined by EH by reading log page 10h.
    1741                 :            :                  */
    1742         [ #  # ]:          0 :                 if (active_qc)
    1743                 :          0 :                         active_qc->err_mask |= AC_ERR_DEV;
    1744                 :            :                 else
    1745                 :          0 :                         active_ehi->err_mask |= AC_ERR_DEV;
    1746                 :            : 
    1747         [ #  # ]:          0 :                 if (hpriv->flags & AHCI_HFLAG_IGN_SERR_INTERNAL)
    1748                 :          0 :                         host_ehi->serror &= ~SERR_INTERNAL;
    1749                 :            :         }
    1750                 :            : 
    1751         [ #  # ]:          0 :         if (irq_stat & PORT_IRQ_UNK_FIS) {
    1752                 :          0 :                 u32 *unk = pp->rx_fis + RX_FIS_UNK;
    1753                 :            : 
    1754                 :          0 :                 active_ehi->err_mask |= AC_ERR_HSM;
    1755                 :          0 :                 active_ehi->action |= ATA_EH_RESET;
    1756                 :          0 :                 ata_ehi_push_desc(active_ehi,
    1757                 :            :                                   "unknown FIS %08x %08x %08x %08x" ,
    1758                 :            :                                   unk[0], unk[1], unk[2], unk[3]);
    1759                 :            :         }
    1760                 :            : 
    1761   [ #  #  #  # ]:          0 :         if (sata_pmp_attached(ap) && (irq_stat & PORT_IRQ_BAD_PMP)) {
    1762                 :          0 :                 active_ehi->err_mask |= AC_ERR_HSM;
    1763                 :          0 :                 active_ehi->action |= ATA_EH_RESET;
    1764                 :          0 :                 ata_ehi_push_desc(active_ehi, "incorrect PMP");
    1765                 :            :         }
    1766                 :            : 
    1767         [ #  # ]:          0 :         if (irq_stat & (PORT_IRQ_HBUS_ERR | PORT_IRQ_HBUS_DATA_ERR)) {
    1768                 :          0 :                 host_ehi->err_mask |= AC_ERR_HOST_BUS;
    1769                 :          0 :                 host_ehi->action |= ATA_EH_RESET;
    1770                 :          0 :                 ata_ehi_push_desc(host_ehi, "host bus error");
    1771                 :            :         }
    1772                 :            : 
    1773         [ #  # ]:          0 :         if (irq_stat & PORT_IRQ_IF_ERR) {
    1774         [ #  # ]:          0 :                 if (fbs_need_dec)
    1775                 :          0 :                         active_ehi->err_mask |= AC_ERR_DEV;
    1776                 :            :                 else {
    1777                 :          0 :                         host_ehi->err_mask |= AC_ERR_ATA_BUS;
    1778                 :          0 :                         host_ehi->action |= ATA_EH_RESET;
    1779                 :            :                 }
    1780                 :            : 
    1781                 :          0 :                 ata_ehi_push_desc(host_ehi, "interface fatal error");
    1782                 :            :         }
    1783                 :            : 
    1784         [ #  # ]:          0 :         if (irq_stat & (PORT_IRQ_CONNECT | PORT_IRQ_PHYRDY)) {
    1785         [ #  # ]:          0 :                 ata_ehi_hotplugged(host_ehi);
    1786                 :          0 :                 ata_ehi_push_desc(host_ehi, "%s",
    1787         [ #  # ]:          0 :                         irq_stat & PORT_IRQ_CONNECT ?
    1788                 :            :                         "connection status changed" : "PHY RDY changed");
    1789                 :            :         }
    1790                 :            : 
    1791                 :            :         /* okay, let's hand over to EH */
    1792                 :            : 
    1793         [ #  # ]:          0 :         if (irq_stat & PORT_IRQ_FREEZE)
    1794                 :          0 :                 ata_port_freeze(ap);
    1795         [ #  # ]:          0 :         else if (fbs_need_dec) {
    1796                 :          0 :                 ata_link_abort(link);
    1797                 :          0 :                 ahci_fbs_dec_intr(ap);
    1798                 :            :         } else
    1799                 :          0 :                 ata_port_abort(ap);
    1800                 :          0 : }
    1801                 :            : 
    1802                 :          0 : static void ahci_handle_port_interrupt(struct ata_port *ap,
    1803                 :            :                                        void __iomem *port_mmio, u32 status)
    1804                 :            : {
    1805                 :          0 :         struct ata_eh_info *ehi = &ap->link.eh_info;
    1806                 :          0 :         struct ahci_port_priv *pp = ap->private_data;
    1807                 :          0 :         struct ahci_host_priv *hpriv = ap->host->private_data;
    1808                 :          0 :         int resetting = !!(ap->pflags & ATA_PFLAG_RESETTING);
    1809                 :          0 :         u32 qc_active = 0;
    1810                 :          0 :         int rc;
    1811                 :            : 
    1812                 :            :         /* ignore BAD_PMP while resetting */
    1813         [ #  # ]:          0 :         if (unlikely(resetting))
    1814                 :          0 :                 status &= ~PORT_IRQ_BAD_PMP;
    1815                 :            : 
    1816         [ #  # ]:          0 :         if (sata_lpm_ignore_phy_events(&ap->link)) {
    1817                 :          0 :                 status &= ~PORT_IRQ_PHYRDY;
    1818                 :          0 :                 ahci_scr_write(&ap->link, SCR_ERROR, SERR_PHYRDY_CHG);
    1819                 :            :         }
    1820                 :            : 
    1821         [ #  # ]:          0 :         if (unlikely(status & PORT_IRQ_ERROR)) {
    1822                 :          0 :                 ahci_error_intr(ap, status);
    1823                 :          0 :                 return;
    1824                 :            :         }
    1825                 :            : 
    1826         [ #  # ]:          0 :         if (status & PORT_IRQ_SDB_FIS) {
    1827                 :            :                 /* If SNotification is available, leave notification
    1828                 :            :                  * handling to sata_async_notification().  If not,
    1829                 :            :                  * emulate it by snooping SDB FIS RX area.
    1830                 :            :                  *
    1831                 :            :                  * Snooping FIS RX area is probably cheaper than
    1832                 :            :                  * poking SNotification but some constrollers which
    1833                 :            :                  * implement SNotification, ICH9 for example, don't
    1834                 :            :                  * store AN SDB FIS into receive area.
    1835                 :            :                  */
    1836         [ #  # ]:          0 :                 if (hpriv->cap & HOST_CAP_SNTF)
    1837                 :          0 :                         sata_async_notification(ap);
    1838                 :            :                 else {
    1839                 :            :                         /* If the 'N' bit in word 0 of the FIS is set,
    1840                 :            :                          * we just received asynchronous notification.
    1841                 :            :                          * Tell libata about it.
    1842                 :            :                          *
    1843                 :            :                          * Lack of SNotification should not appear in
    1844                 :            :                          * ahci 1.2, so the workaround is unnecessary
    1845                 :            :                          * when FBS is enabled.
    1846                 :            :                          */
    1847         [ #  # ]:          0 :                         if (pp->fbs_enabled)
    1848                 :          0 :                                 WARN_ON_ONCE(1);
    1849                 :            :                         else {
    1850                 :          0 :                                 const __le32 *f = pp->rx_fis + RX_FIS_SDB;
    1851                 :          0 :                                 u32 f0 = le32_to_cpu(f[0]);
    1852         [ #  # ]:          0 :                                 if (f0 & (1 << 15))
    1853                 :          0 :                                         sata_async_notification(ap);
    1854                 :            :                         }
    1855                 :            :                 }
    1856                 :            :         }
    1857                 :            : 
    1858                 :            :         /* pp->active_link is not reliable once FBS is enabled, both
    1859                 :            :          * PORT_SCR_ACT and PORT_CMD_ISSUE should be checked because
    1860                 :            :          * NCQ and non-NCQ commands may be in flight at the same time.
    1861                 :            :          */
    1862         [ #  # ]:          0 :         if (pp->fbs_enabled) {
    1863         [ #  # ]:          0 :                 if (ap->qc_active) {
    1864                 :          0 :                         qc_active = readl(port_mmio + PORT_SCR_ACT);
    1865                 :          0 :                         qc_active |= readl(port_mmio + PORT_CMD_ISSUE);
    1866                 :            :                 }
    1867                 :            :         } else {
    1868                 :            :                 /* pp->active_link is valid iff any command is in flight */
    1869   [ #  #  #  # ]:          0 :                 if (ap->qc_active && pp->active_link->sactive)
    1870                 :          0 :                         qc_active = readl(port_mmio + PORT_SCR_ACT);
    1871                 :            :                 else
    1872                 :          0 :                         qc_active = readl(port_mmio + PORT_CMD_ISSUE);
    1873                 :            :         }
    1874                 :            : 
    1875                 :            : 
    1876                 :          0 :         rc = ata_qc_complete_multiple(ap, qc_active);
    1877                 :            : 
    1878                 :            :         /* while resetting, invalid completions are expected */
    1879         [ #  # ]:          0 :         if (unlikely(rc < 0 && !resetting)) {
    1880                 :          0 :                 ehi->err_mask |= AC_ERR_HSM;
    1881                 :          0 :                 ehi->action |= ATA_EH_RESET;
    1882                 :          0 :                 ata_port_freeze(ap);
    1883                 :            :         }
    1884                 :            : }
    1885                 :            : 
    1886                 :          0 : static void ahci_port_intr(struct ata_port *ap)
    1887                 :            : {
    1888                 :          0 :         void __iomem *port_mmio = ahci_port_base(ap);
    1889                 :          0 :         u32 status;
    1890                 :            : 
    1891                 :          0 :         status = readl(port_mmio + PORT_IRQ_STAT);
    1892                 :          0 :         writel(status, port_mmio + PORT_IRQ_STAT);
    1893                 :            : 
    1894                 :          0 :         ahci_handle_port_interrupt(ap, port_mmio, status);
    1895                 :          0 : }
    1896                 :            : 
    1897                 :          0 : static irqreturn_t ahci_multi_irqs_intr_hard(int irq, void *dev_instance)
    1898                 :            : {
    1899                 :          0 :         struct ata_port *ap = dev_instance;
    1900                 :          0 :         void __iomem *port_mmio = ahci_port_base(ap);
    1901                 :          0 :         u32 status;
    1902                 :            : 
    1903                 :          0 :         VPRINTK("ENTER\n");
    1904                 :            : 
    1905                 :          0 :         status = readl(port_mmio + PORT_IRQ_STAT);
    1906                 :          0 :         writel(status, port_mmio + PORT_IRQ_STAT);
    1907                 :            : 
    1908                 :          0 :         spin_lock(ap->lock);
    1909                 :          0 :         ahci_handle_port_interrupt(ap, port_mmio, status);
    1910                 :          0 :         spin_unlock(ap->lock);
    1911                 :            : 
    1912                 :          0 :         VPRINTK("EXIT\n");
    1913                 :            : 
    1914                 :          0 :         return IRQ_HANDLED;
    1915                 :            : }
    1916                 :            : 
    1917                 :          0 : u32 ahci_handle_port_intr(struct ata_host *host, u32 irq_masked)
    1918                 :            : {
    1919                 :          0 :         unsigned int i, handled = 0;
    1920                 :            : 
    1921         [ #  # ]:          0 :         for (i = 0; i < host->n_ports; i++) {
    1922                 :          0 :                 struct ata_port *ap;
    1923                 :            : 
    1924         [ #  # ]:          0 :                 if (!(irq_masked & (1 << i)))
    1925                 :          0 :                         continue;
    1926                 :            : 
    1927                 :          0 :                 ap = host->ports[i];
    1928         [ #  # ]:          0 :                 if (ap) {
    1929                 :          0 :                         ahci_port_intr(ap);
    1930                 :          0 :                         VPRINTK("port %u\n", i);
    1931                 :            :                 } else {
    1932                 :          0 :                         VPRINTK("port %u (no irq)\n", i);
    1933         [ #  # ]:          0 :                         if (ata_ratelimit())
    1934                 :          0 :                                 dev_warn(host->dev,
    1935                 :            :                                          "interrupt on disabled port %u\n", i);
    1936                 :            :                 }
    1937                 :            : 
    1938                 :            :                 handled = 1;
    1939                 :            :         }
    1940                 :            : 
    1941                 :          0 :         return handled;
    1942                 :            : }
    1943                 :            : EXPORT_SYMBOL_GPL(ahci_handle_port_intr);
    1944                 :            : 
    1945                 :          0 : static irqreturn_t ahci_single_level_irq_intr(int irq, void *dev_instance)
    1946                 :            : {
    1947                 :          0 :         struct ata_host *host = dev_instance;
    1948                 :          0 :         struct ahci_host_priv *hpriv;
    1949                 :          0 :         unsigned int rc = 0;
    1950                 :          0 :         void __iomem *mmio;
    1951                 :          0 :         u32 irq_stat, irq_masked;
    1952                 :            : 
    1953                 :          0 :         VPRINTK("ENTER\n");
    1954                 :            : 
    1955                 :          0 :         hpriv = host->private_data;
    1956                 :          0 :         mmio = hpriv->mmio;
    1957                 :            : 
    1958                 :            :         /* sigh.  0xffffffff is a valid return from h/w */
    1959                 :          0 :         irq_stat = readl(mmio + HOST_IRQ_STAT);
    1960         [ #  # ]:          0 :         if (!irq_stat)
    1961                 :            :                 return IRQ_NONE;
    1962                 :            : 
    1963                 :          0 :         irq_masked = irq_stat & hpriv->port_map;
    1964                 :            : 
    1965                 :          0 :         spin_lock(&host->lock);
    1966                 :            : 
    1967                 :          0 :         rc = ahci_handle_port_intr(host, irq_masked);
    1968                 :            : 
    1969                 :            :         /* HOST_IRQ_STAT behaves as level triggered latch meaning that
    1970                 :            :          * it should be cleared after all the port events are cleared;
    1971                 :            :          * otherwise, it will raise a spurious interrupt after each
    1972                 :            :          * valid one.  Please read section 10.6.2 of ahci 1.1 for more
    1973                 :            :          * information.
    1974                 :            :          *
    1975                 :            :          * Also, use the unmasked value to clear interrupt as spurious
    1976                 :            :          * pending event on a dummy port might cause screaming IRQ.
    1977                 :            :          */
    1978                 :          0 :         writel(irq_stat, mmio + HOST_IRQ_STAT);
    1979                 :            : 
    1980                 :          0 :         spin_unlock(&host->lock);
    1981                 :            : 
    1982                 :          0 :         VPRINTK("EXIT\n");
    1983                 :            : 
    1984                 :          0 :         return IRQ_RETVAL(rc);
    1985                 :            : }
    1986                 :            : 
    1987                 :          0 : unsigned int ahci_qc_issue(struct ata_queued_cmd *qc)
    1988                 :            : {
    1989                 :          0 :         struct ata_port *ap = qc->ap;
    1990         [ #  # ]:          0 :         void __iomem *port_mmio = ahci_port_base(ap);
    1991                 :          0 :         struct ahci_port_priv *pp = ap->private_data;
    1992                 :            : 
    1993                 :            :         /* Keep track of the currently active link.  It will be used
    1994                 :            :          * in completion path to determine whether NCQ phase is in
    1995                 :            :          * progress.
    1996                 :            :          */
    1997                 :          0 :         pp->active_link = qc->dev->link;
    1998                 :            : 
    1999         [ #  # ]:          0 :         if (ata_is_ncq(qc->tf.protocol))
    2000                 :          0 :                 writel(1 << qc->hw_tag, port_mmio + PORT_SCR_ACT);
    2001                 :            : 
    2002   [ #  #  #  # ]:          0 :         if (pp->fbs_enabled && pp->fbs_last_dev != qc->dev->link->pmp) {
    2003                 :          0 :                 u32 fbs = readl(port_mmio + PORT_FBS);
    2004                 :          0 :                 fbs &= ~(PORT_FBS_DEV_MASK | PORT_FBS_DEC);
    2005                 :          0 :                 fbs |= qc->dev->link->pmp << PORT_FBS_DEV_OFFSET;
    2006                 :          0 :                 writel(fbs, port_mmio + PORT_FBS);
    2007                 :          0 :                 pp->fbs_last_dev = qc->dev->link->pmp;
    2008                 :            :         }
    2009                 :            : 
    2010                 :          0 :         writel(1 << qc->hw_tag, port_mmio + PORT_CMD_ISSUE);
    2011                 :            : 
    2012                 :          0 :         ahci_sw_activity(qc->dev->link);
    2013                 :            : 
    2014                 :          0 :         return 0;
    2015                 :            : }
    2016                 :            : EXPORT_SYMBOL_GPL(ahci_qc_issue);
    2017                 :            : 
    2018                 :          0 : static bool ahci_qc_fill_rtf(struct ata_queued_cmd *qc)
    2019                 :            : {
    2020                 :          0 :         struct ahci_port_priv *pp = qc->ap->private_data;
    2021                 :          0 :         u8 *rx_fis = pp->rx_fis;
    2022                 :            : 
    2023         [ #  # ]:          0 :         if (pp->fbs_enabled)
    2024                 :          0 :                 rx_fis += qc->dev->link->pmp * AHCI_RX_FIS_SZ;
    2025                 :            : 
    2026                 :            :         /*
    2027                 :            :          * After a successful execution of an ATA PIO data-in command,
    2028                 :            :          * the device doesn't send D2H Reg FIS to update the TF and
    2029                 :            :          * the host should take TF and E_Status from the preceding PIO
    2030                 :            :          * Setup FIS.
    2031                 :            :          */
    2032   [ #  #  #  # ]:          0 :         if (qc->tf.protocol == ATA_PROT_PIO && qc->dma_dir == DMA_FROM_DEVICE &&
    2033         [ #  # ]:          0 :             !(qc->flags & ATA_QCFLAG_FAILED)) {
    2034                 :          0 :                 ata_tf_from_fis(rx_fis + RX_FIS_PIO_SETUP, &qc->result_tf);
    2035                 :          0 :                 qc->result_tf.command = (rx_fis + RX_FIS_PIO_SETUP)[15];
    2036                 :            :         } else
    2037                 :          0 :                 ata_tf_from_fis(rx_fis + RX_FIS_D2H_REG, &qc->result_tf);
    2038                 :            : 
    2039                 :          0 :         return true;
    2040                 :            : }
    2041                 :            : 
    2042                 :          0 : static void ahci_freeze(struct ata_port *ap)
    2043                 :            : {
    2044                 :          0 :         void __iomem *port_mmio = ahci_port_base(ap);
    2045                 :            : 
    2046                 :            :         /* turn IRQ off */
    2047                 :          0 :         writel(0, port_mmio + PORT_IRQ_MASK);
    2048                 :          0 : }
    2049                 :            : 
    2050                 :          0 : static void ahci_thaw(struct ata_port *ap)
    2051                 :            : {
    2052                 :          0 :         struct ahci_host_priv *hpriv = ap->host->private_data;
    2053                 :          0 :         void __iomem *mmio = hpriv->mmio;
    2054                 :          0 :         void __iomem *port_mmio = ahci_port_base(ap);
    2055                 :          0 :         u32 tmp;
    2056                 :          0 :         struct ahci_port_priv *pp = ap->private_data;
    2057                 :            : 
    2058                 :            :         /* clear IRQ */
    2059                 :          0 :         tmp = readl(port_mmio + PORT_IRQ_STAT);
    2060                 :          0 :         writel(tmp, port_mmio + PORT_IRQ_STAT);
    2061                 :          0 :         writel(1 << ap->port_no, mmio + HOST_IRQ_STAT);
    2062                 :            : 
    2063                 :            :         /* turn IRQ back on */
    2064                 :          0 :         writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK);
    2065                 :          0 : }
    2066                 :            : 
    2067                 :          0 : void ahci_error_handler(struct ata_port *ap)
    2068                 :            : {
    2069                 :          0 :         struct ahci_host_priv *hpriv = ap->host->private_data;
    2070                 :            : 
    2071         [ #  # ]:          0 :         if (!(ap->pflags & ATA_PFLAG_FROZEN)) {
    2072                 :            :                 /* restart engine */
    2073                 :          0 :                 hpriv->stop_engine(ap);
    2074                 :          0 :                 hpriv->start_engine(ap);
    2075                 :            :         }
    2076                 :            : 
    2077                 :          0 :         sata_pmp_error_handler(ap);
    2078                 :            : 
    2079   [ #  #  #  # ]:          0 :         if (!ata_dev_enabled(ap->link.device))
    2080                 :          0 :                 hpriv->stop_engine(ap);
    2081                 :          0 : }
    2082                 :            : EXPORT_SYMBOL_GPL(ahci_error_handler);
    2083                 :            : 
    2084                 :          0 : static void ahci_post_internal_cmd(struct ata_queued_cmd *qc)
    2085                 :            : {
    2086                 :          0 :         struct ata_port *ap = qc->ap;
    2087                 :            : 
    2088                 :            :         /* make DMA engine forget about the failed command */
    2089         [ #  # ]:          0 :         if (qc->flags & ATA_QCFLAG_FAILED)
    2090                 :          0 :                 ahci_kick_engine(ap);
    2091                 :          0 : }
    2092                 :            : 
    2093                 :          0 : static void ahci_set_aggressive_devslp(struct ata_port *ap, bool sleep)
    2094                 :            : {
    2095                 :          0 :         struct ahci_host_priv *hpriv = ap->host->private_data;
    2096                 :          0 :         void __iomem *port_mmio = ahci_port_base(ap);
    2097                 :          0 :         struct ata_device *dev = ap->link.device;
    2098                 :          0 :         u32 devslp, dm, dito, mdat, deto, dito_conf;
    2099                 :          0 :         int rc;
    2100                 :          0 :         unsigned int err_mask;
    2101                 :            : 
    2102                 :          0 :         devslp = readl(port_mmio + PORT_DEVSLP);
    2103         [ #  # ]:          0 :         if (!(devslp & PORT_DEVSLP_DSP)) {
    2104                 :          0 :                 dev_info(ap->host->dev, "port does not support device sleep\n");
    2105                 :          0 :                 return;
    2106                 :            :         }
    2107                 :            : 
    2108                 :            :         /* disable device sleep */
    2109         [ #  # ]:          0 :         if (!sleep) {
    2110         [ #  # ]:          0 :                 if (devslp & PORT_DEVSLP_ADSE) {
    2111                 :          0 :                         writel(devslp & ~PORT_DEVSLP_ADSE,
    2112                 :            :                                port_mmio + PORT_DEVSLP);
    2113                 :          0 :                         err_mask = ata_dev_set_feature(dev,
    2114                 :            :                                                        SETFEATURES_SATA_DISABLE,
    2115                 :            :                                                        SATA_DEVSLP);
    2116         [ #  # ]:          0 :                         if (err_mask && err_mask != AC_ERR_DEV)
    2117                 :          0 :                                 ata_dev_warn(dev, "failed to disable DEVSLP\n");
    2118                 :            :                 }
    2119                 :          0 :                 return;
    2120                 :            :         }
    2121                 :            : 
    2122                 :          0 :         dm = (devslp & PORT_DEVSLP_DM_MASK) >> PORT_DEVSLP_DM_OFFSET;
    2123                 :          0 :         dito = devslp_idle_timeout / (dm + 1);
    2124                 :          0 :         if (dito > 0x3ff)
    2125                 :            :                 dito = 0x3ff;
    2126                 :            : 
    2127                 :          0 :         dito_conf = (devslp >> PORT_DEVSLP_DITO_OFFSET) & 0x3FF;
    2128                 :            : 
    2129                 :            :         /* device sleep was already enabled and same dito */
    2130   [ #  #  #  # ]:          0 :         if ((devslp & PORT_DEVSLP_ADSE) && (dito_conf == dito))
    2131                 :            :                 return;
    2132                 :            : 
    2133                 :            :         /* set DITO, MDAT, DETO and enable DevSlp, need to stop engine first */
    2134                 :          0 :         rc = hpriv->stop_engine(ap);
    2135         [ #  # ]:          0 :         if (rc)
    2136                 :            :                 return;
    2137                 :            : 
    2138                 :            :         /* Use the nominal value 10 ms if the read MDAT is zero,
    2139                 :            :          * the nominal value of DETO is 20 ms.
    2140                 :            :          */
    2141         [ #  # ]:          0 :         if (dev->devslp_timing[ATA_LOG_DEVSLP_VALID] &
    2142                 :            :             ATA_LOG_DEVSLP_VALID_MASK) {
    2143                 :          0 :                 mdat = dev->devslp_timing[ATA_LOG_DEVSLP_MDAT] &
    2144                 :            :                        ATA_LOG_DEVSLP_MDAT_MASK;
    2145         [ #  # ]:          0 :                 if (!mdat)
    2146                 :          0 :                         mdat = 10;
    2147                 :          0 :                 deto = dev->devslp_timing[ATA_LOG_DEVSLP_DETO];
    2148         [ #  # ]:          0 :                 if (!deto)
    2149                 :          0 :                         deto = 20;
    2150                 :            :         } else {
    2151                 :            :                 mdat = 10;
    2152                 :            :                 deto = 20;
    2153                 :            :         }
    2154                 :            : 
    2155                 :            :         /* Make dito, mdat, deto bits to 0s */
    2156                 :          0 :         devslp &= ~GENMASK_ULL(24, 2);
    2157                 :          0 :         devslp |= ((dito << PORT_DEVSLP_DITO_OFFSET) |
    2158                 :          0 :                    (mdat << PORT_DEVSLP_MDAT_OFFSET) |
    2159                 :          0 :                    (deto << PORT_DEVSLP_DETO_OFFSET) |
    2160                 :            :                    PORT_DEVSLP_ADSE);
    2161                 :          0 :         writel(devslp, port_mmio + PORT_DEVSLP);
    2162                 :            : 
    2163                 :          0 :         hpriv->start_engine(ap);
    2164                 :            : 
    2165                 :            :         /* enable device sleep feature for the drive */
    2166                 :          0 :         err_mask = ata_dev_set_feature(dev,
    2167                 :            :                                        SETFEATURES_SATA_ENABLE,
    2168                 :            :                                        SATA_DEVSLP);
    2169         [ #  # ]:          0 :         if (err_mask && err_mask != AC_ERR_DEV)
    2170                 :          0 :                 ata_dev_warn(dev, "failed to enable DEVSLP\n");
    2171                 :            : }
    2172                 :            : 
    2173                 :          0 : static void ahci_enable_fbs(struct ata_port *ap)
    2174                 :            : {
    2175                 :          0 :         struct ahci_host_priv *hpriv = ap->host->private_data;
    2176                 :          0 :         struct ahci_port_priv *pp = ap->private_data;
    2177         [ #  # ]:          0 :         void __iomem *port_mmio = ahci_port_base(ap);
    2178                 :          0 :         u32 fbs;
    2179                 :          0 :         int rc;
    2180                 :            : 
    2181         [ #  # ]:          0 :         if (!pp->fbs_supported)
    2182                 :            :                 return;
    2183                 :            : 
    2184                 :          0 :         fbs = readl(port_mmio + PORT_FBS);
    2185         [ #  # ]:          0 :         if (fbs & PORT_FBS_EN) {
    2186                 :          0 :                 pp->fbs_enabled = true;
    2187                 :          0 :                 pp->fbs_last_dev = -1; /* initialization */
    2188                 :          0 :                 return;
    2189                 :            :         }
    2190                 :            : 
    2191                 :          0 :         rc = hpriv->stop_engine(ap);
    2192         [ #  # ]:          0 :         if (rc)
    2193                 :            :                 return;
    2194                 :            : 
    2195                 :          0 :         writel(fbs | PORT_FBS_EN, port_mmio + PORT_FBS);
    2196                 :          0 :         fbs = readl(port_mmio + PORT_FBS);
    2197         [ #  # ]:          0 :         if (fbs & PORT_FBS_EN) {
    2198                 :          0 :                 dev_info(ap->host->dev, "FBS is enabled\n");
    2199                 :          0 :                 pp->fbs_enabled = true;
    2200                 :          0 :                 pp->fbs_last_dev = -1; /* initialization */
    2201                 :            :         } else
    2202                 :          0 :                 dev_err(ap->host->dev, "Failed to enable FBS\n");
    2203                 :            : 
    2204                 :          0 :         hpriv->start_engine(ap);
    2205                 :            : }
    2206                 :            : 
    2207                 :          0 : static void ahci_disable_fbs(struct ata_port *ap)
    2208                 :            : {
    2209                 :          0 :         struct ahci_host_priv *hpriv = ap->host->private_data;
    2210                 :          0 :         struct ahci_port_priv *pp = ap->private_data;
    2211         [ #  # ]:          0 :         void __iomem *port_mmio = ahci_port_base(ap);
    2212                 :          0 :         u32 fbs;
    2213                 :          0 :         int rc;
    2214                 :            : 
    2215         [ #  # ]:          0 :         if (!pp->fbs_supported)
    2216                 :            :                 return;
    2217                 :            : 
    2218                 :          0 :         fbs = readl(port_mmio + PORT_FBS);
    2219         [ #  # ]:          0 :         if ((fbs & PORT_FBS_EN) == 0) {
    2220                 :          0 :                 pp->fbs_enabled = false;
    2221                 :          0 :                 return;
    2222                 :            :         }
    2223                 :            : 
    2224                 :          0 :         rc = hpriv->stop_engine(ap);
    2225         [ #  # ]:          0 :         if (rc)
    2226                 :            :                 return;
    2227                 :            : 
    2228                 :          0 :         writel(fbs & ~PORT_FBS_EN, port_mmio + PORT_FBS);
    2229                 :          0 :         fbs = readl(port_mmio + PORT_FBS);
    2230         [ #  # ]:          0 :         if (fbs & PORT_FBS_EN)
    2231                 :          0 :                 dev_err(ap->host->dev, "Failed to disable FBS\n");
    2232                 :            :         else {
    2233                 :          0 :                 dev_info(ap->host->dev, "FBS is disabled\n");
    2234                 :          0 :                 pp->fbs_enabled = false;
    2235                 :            :         }
    2236                 :            : 
    2237                 :          0 :         hpriv->start_engine(ap);
    2238                 :            : }
    2239                 :            : 
    2240                 :          0 : static void ahci_pmp_attach(struct ata_port *ap)
    2241                 :            : {
    2242                 :          0 :         void __iomem *port_mmio = ahci_port_base(ap);
    2243                 :          0 :         struct ahci_port_priv *pp = ap->private_data;
    2244                 :          0 :         u32 cmd;
    2245                 :            : 
    2246                 :          0 :         cmd = readl(port_mmio + PORT_CMD);
    2247                 :          0 :         cmd |= PORT_CMD_PMP;
    2248                 :          0 :         writel(cmd, port_mmio + PORT_CMD);
    2249                 :            : 
    2250                 :          0 :         ahci_enable_fbs(ap);
    2251                 :            : 
    2252                 :          0 :         pp->intr_mask |= PORT_IRQ_BAD_PMP;
    2253                 :            : 
    2254                 :            :         /*
    2255                 :            :          * We must not change the port interrupt mask register if the
    2256                 :            :          * port is marked frozen, the value in pp->intr_mask will be
    2257                 :            :          * restored later when the port is thawed.
    2258                 :            :          *
    2259                 :            :          * Note that during initialization, the port is marked as
    2260                 :            :          * frozen since the irq handler is not yet registered.
    2261                 :            :          */
    2262         [ #  # ]:          0 :         if (!(ap->pflags & ATA_PFLAG_FROZEN))
    2263                 :          0 :                 writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK);
    2264                 :          0 : }
    2265                 :            : 
    2266                 :          0 : static void ahci_pmp_detach(struct ata_port *ap)
    2267                 :            : {
    2268                 :          0 :         void __iomem *port_mmio = ahci_port_base(ap);
    2269                 :          0 :         struct ahci_port_priv *pp = ap->private_data;
    2270                 :          0 :         u32 cmd;
    2271                 :            : 
    2272                 :          0 :         ahci_disable_fbs(ap);
    2273                 :            : 
    2274                 :          0 :         cmd = readl(port_mmio + PORT_CMD);
    2275                 :          0 :         cmd &= ~PORT_CMD_PMP;
    2276                 :          0 :         writel(cmd, port_mmio + PORT_CMD);
    2277                 :            : 
    2278                 :          0 :         pp->intr_mask &= ~PORT_IRQ_BAD_PMP;
    2279                 :            : 
    2280                 :            :         /* see comment above in ahci_pmp_attach() */
    2281         [ #  # ]:          0 :         if (!(ap->pflags & ATA_PFLAG_FROZEN))
    2282                 :          0 :                 writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK);
    2283                 :          0 : }
    2284                 :            : 
    2285                 :          0 : int ahci_port_resume(struct ata_port *ap)
    2286                 :            : {
    2287                 :          0 :         ahci_rpm_get_port(ap);
    2288                 :            : 
    2289                 :          0 :         ahci_power_up(ap);
    2290                 :          0 :         ahci_start_port(ap);
    2291                 :            : 
    2292         [ #  # ]:          0 :         if (sata_pmp_attached(ap))
    2293                 :          0 :                 ahci_pmp_attach(ap);
    2294                 :            :         else
    2295                 :          0 :                 ahci_pmp_detach(ap);
    2296                 :            : 
    2297                 :          0 :         return 0;
    2298                 :            : }
    2299                 :            : EXPORT_SYMBOL_GPL(ahci_port_resume);
    2300                 :            : 
    2301                 :            : #ifdef CONFIG_PM
    2302                 :          0 : static int ahci_port_suspend(struct ata_port *ap, pm_message_t mesg)
    2303                 :            : {
    2304                 :          0 :         const char *emsg = NULL;
    2305                 :          0 :         int rc;
    2306                 :            : 
    2307                 :          0 :         rc = ahci_deinit_port(ap, &emsg);
    2308         [ #  # ]:          0 :         if (rc == 0)
    2309                 :          0 :                 ahci_power_down(ap);
    2310                 :            :         else {
    2311                 :          0 :                 ata_port_err(ap, "%s (%d)\n", emsg, rc);
    2312                 :          0 :                 ata_port_freeze(ap);
    2313                 :            :         }
    2314                 :            : 
    2315                 :          0 :         ahci_rpm_put_port(ap);
    2316                 :          0 :         return rc;
    2317                 :            : }
    2318                 :            : #endif
    2319                 :            : 
    2320                 :          0 : static int ahci_port_start(struct ata_port *ap)
    2321                 :            : {
    2322                 :          0 :         struct ahci_host_priv *hpriv = ap->host->private_data;
    2323                 :          0 :         struct device *dev = ap->host->dev;
    2324                 :          0 :         struct ahci_port_priv *pp;
    2325                 :          0 :         void *mem;
    2326                 :          0 :         dma_addr_t mem_dma;
    2327                 :          0 :         size_t dma_sz, rx_fis_sz;
    2328                 :            : 
    2329                 :          0 :         pp = devm_kzalloc(dev, sizeof(*pp), GFP_KERNEL);
    2330         [ #  # ]:          0 :         if (!pp)
    2331                 :            :                 return -ENOMEM;
    2332                 :            : 
    2333         [ #  # ]:          0 :         if (ap->host->n_ports > 1) {
    2334                 :          0 :                 pp->irq_desc = devm_kzalloc(dev, 8, GFP_KERNEL);
    2335         [ #  # ]:          0 :                 if (!pp->irq_desc) {
    2336                 :          0 :                         devm_kfree(dev, pp);
    2337                 :          0 :                         return -ENOMEM;
    2338                 :            :                 }
    2339                 :          0 :                 snprintf(pp->irq_desc, 8,
    2340                 :            :                          "%s%d", dev_driver_string(dev), ap->port_no);
    2341                 :            :         }
    2342                 :            : 
    2343                 :            :         /* check FBS capability */
    2344   [ #  #  #  # ]:          0 :         if ((hpriv->cap & HOST_CAP_FBS) && sata_pmp_supported(ap)) {
    2345                 :          0 :                 void __iomem *port_mmio = ahci_port_base(ap);
    2346                 :          0 :                 u32 cmd = readl(port_mmio + PORT_CMD);
    2347         [ #  # ]:          0 :                 if (cmd & PORT_CMD_FBSCP)
    2348                 :          0 :                         pp->fbs_supported = true;
    2349         [ #  # ]:          0 :                 else if (hpriv->flags & AHCI_HFLAG_YES_FBS) {
    2350                 :          0 :                         dev_info(dev, "port %d can do FBS, forcing FBSCP\n",
    2351                 :            :                                  ap->port_no);
    2352                 :          0 :                         pp->fbs_supported = true;
    2353                 :            :                 } else
    2354                 :          0 :                         dev_warn(dev, "port %d is not capable of FBS\n",
    2355                 :            :                                  ap->port_no);
    2356                 :            :         }
    2357                 :            : 
    2358         [ #  # ]:          0 :         if (pp->fbs_supported) {
    2359                 :            :                 dma_sz = AHCI_PORT_PRIV_FBS_DMA_SZ;
    2360                 :            :                 rx_fis_sz = AHCI_RX_FIS_SZ * 16;
    2361                 :            :         } else {
    2362                 :          0 :                 dma_sz = AHCI_PORT_PRIV_DMA_SZ;
    2363                 :          0 :                 rx_fis_sz = AHCI_RX_FIS_SZ;
    2364                 :            :         }
    2365                 :            : 
    2366                 :          0 :         mem = dmam_alloc_coherent(dev, dma_sz, &mem_dma, GFP_KERNEL);
    2367         [ #  # ]:          0 :         if (!mem)
    2368                 :            :                 return -ENOMEM;
    2369                 :            : 
    2370                 :            :         /*
    2371                 :            :          * First item in chunk of DMA memory: 32-slot command table,
    2372                 :            :          * 32 bytes each in size
    2373                 :            :          */
    2374                 :          0 :         pp->cmd_slot = mem;
    2375                 :          0 :         pp->cmd_slot_dma = mem_dma;
    2376                 :            : 
    2377                 :          0 :         mem += AHCI_CMD_SLOT_SZ;
    2378                 :          0 :         mem_dma += AHCI_CMD_SLOT_SZ;
    2379                 :            : 
    2380                 :            :         /*
    2381                 :            :          * Second item: Received-FIS area
    2382                 :            :          */
    2383                 :          0 :         pp->rx_fis = mem;
    2384                 :          0 :         pp->rx_fis_dma = mem_dma;
    2385                 :            : 
    2386                 :          0 :         mem += rx_fis_sz;
    2387                 :          0 :         mem_dma += rx_fis_sz;
    2388                 :            : 
    2389                 :            :         /*
    2390                 :            :          * Third item: data area for storing a single command
    2391                 :            :          * and its scatter-gather table
    2392                 :            :          */
    2393                 :          0 :         pp->cmd_tbl = mem;
    2394                 :          0 :         pp->cmd_tbl_dma = mem_dma;
    2395                 :            : 
    2396                 :            :         /*
    2397                 :            :          * Save off initial list of interrupts to be enabled.
    2398                 :            :          * This could be changed later
    2399                 :            :          */
    2400                 :          0 :         pp->intr_mask = DEF_PORT_IRQ;
    2401                 :            : 
    2402                 :            :         /*
    2403                 :            :          * Switch to per-port locking in case each port has its own MSI vector.
    2404                 :            :          */
    2405         [ #  # ]:          0 :         if (hpriv->flags & AHCI_HFLAG_MULTI_MSI) {
    2406                 :          0 :                 spin_lock_init(&pp->lock);
    2407                 :          0 :                 ap->lock = &pp->lock;
    2408                 :            :         }
    2409                 :            : 
    2410                 :          0 :         ap->private_data = pp;
    2411                 :            : 
    2412                 :            :         /* engage engines, captain */
    2413                 :          0 :         return ahci_port_resume(ap);
    2414                 :            : }
    2415                 :            : 
    2416                 :          0 : static void ahci_port_stop(struct ata_port *ap)
    2417                 :            : {
    2418                 :          0 :         const char *emsg = NULL;
    2419                 :          0 :         struct ahci_host_priv *hpriv = ap->host->private_data;
    2420                 :          0 :         void __iomem *host_mmio = hpriv->mmio;
    2421                 :          0 :         int rc;
    2422                 :            : 
    2423                 :            :         /* de-initialize port */
    2424                 :          0 :         rc = ahci_deinit_port(ap, &emsg);
    2425         [ #  # ]:          0 :         if (rc)
    2426                 :          0 :                 ata_port_warn(ap, "%s (%d)\n", emsg, rc);
    2427                 :            : 
    2428                 :            :         /*
    2429                 :            :          * Clear GHC.IS to prevent stuck INTx after disabling MSI and
    2430                 :            :          * re-enabling INTx.
    2431                 :            :          */
    2432                 :          0 :         writel(1 << ap->port_no, host_mmio + HOST_IRQ_STAT);
    2433                 :            : 
    2434                 :          0 :         ahci_rpm_put_port(ap);
    2435                 :          0 : }
    2436                 :            : 
    2437                 :          0 : void ahci_print_info(struct ata_host *host, const char *scc_s)
    2438                 :            : {
    2439                 :          0 :         struct ahci_host_priv *hpriv = host->private_data;
    2440                 :          0 :         u32 vers, cap, cap2, impl, speed;
    2441                 :          0 :         const char *speed_s;
    2442                 :            : 
    2443                 :          0 :         vers = hpriv->version;
    2444                 :          0 :         cap = hpriv->cap;
    2445                 :          0 :         cap2 = hpriv->cap2;
    2446                 :          0 :         impl = hpriv->port_map;
    2447                 :            : 
    2448                 :          0 :         speed = (cap >> 20) & 0xf;
    2449         [ #  # ]:          0 :         if (speed == 1)
    2450                 :            :                 speed_s = "1.5";
    2451         [ #  # ]:          0 :         else if (speed == 2)
    2452                 :            :                 speed_s = "3";
    2453         [ #  # ]:          0 :         else if (speed == 3)
    2454                 :            :                 speed_s = "6";
    2455                 :            :         else
    2456                 :          0 :                 speed_s = "?";
    2457                 :            : 
    2458                 :          0 :         dev_info(host->dev,
    2459                 :            :                 "AHCI %02x%02x.%02x%02x "
    2460                 :            :                 "%u slots %u ports %s Gbps 0x%x impl %s mode\n"
    2461                 :            :                 ,
    2462                 :            : 
    2463                 :            :                 (vers >> 24) & 0xff,
    2464                 :            :                 (vers >> 16) & 0xff,
    2465                 :            :                 (vers >> 8) & 0xff,
    2466                 :            :                 vers & 0xff,
    2467                 :            : 
    2468                 :            :                 ((cap >> 8) & 0x1f) + 1,
    2469                 :            :                 (cap & 0x1f) + 1,
    2470                 :            :                 speed_s,
    2471                 :            :                 impl,
    2472                 :            :                 scc_s);
    2473                 :            : 
    2474   [ #  #  #  #  :          0 :         dev_info(host->dev,
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    2475                 :            :                 "flags: "
    2476                 :            :                 "%s%s%s%s%s%s%s"
    2477                 :            :                 "%s%s%s%s%s%s%s"
    2478                 :            :                 "%s%s%s%s%s%s%s"
    2479                 :            :                 "%s%s\n"
    2480                 :            :                 ,
    2481                 :            : 
    2482                 :            :                 cap & HOST_CAP_64 ? "64bit " : "",
    2483                 :            :                 cap & HOST_CAP_NCQ ? "ncq " : "",
    2484                 :            :                 cap & HOST_CAP_SNTF ? "sntf " : "",
    2485                 :            :                 cap & HOST_CAP_MPS ? "ilck " : "",
    2486                 :            :                 cap & HOST_CAP_SSS ? "stag " : "",
    2487                 :            :                 cap & HOST_CAP_ALPM ? "pm " : "",
    2488                 :            :                 cap & HOST_CAP_LED ? "led " : "",
    2489                 :            :                 cap & HOST_CAP_CLO ? "clo " : "",
    2490                 :            :                 cap & HOST_CAP_ONLY ? "only " : "",
    2491                 :            :                 cap & HOST_CAP_PMP ? "pmp " : "",
    2492                 :            :                 cap & HOST_CAP_FBS ? "fbs " : "",
    2493                 :            :                 cap & HOST_CAP_PIO_MULTI ? "pio " : "",
    2494                 :            :                 cap & HOST_CAP_SSC ? "slum " : "",
    2495                 :            :                 cap & HOST_CAP_PART ? "part " : "",
    2496                 :            :                 cap & HOST_CAP_CCC ? "ccc " : "",
    2497                 :            :                 cap & HOST_CAP_EMS ? "ems " : "",
    2498                 :            :                 cap & HOST_CAP_SXS ? "sxs " : "",
    2499                 :            :                 cap2 & HOST_CAP2_DESO ? "deso " : "",
    2500                 :            :                 cap2 & HOST_CAP2_SADM ? "sadm " : "",
    2501                 :            :                 cap2 & HOST_CAP2_SDS ? "sds " : "",
    2502                 :            :                 cap2 & HOST_CAP2_APST ? "apst " : "",
    2503                 :            :                 cap2 & HOST_CAP2_NVMHCI ? "nvmp " : "",
    2504                 :            :                 cap2 & HOST_CAP2_BOH ? "boh " : ""
    2505                 :            :                 );
    2506                 :          0 : }
    2507                 :            : EXPORT_SYMBOL_GPL(ahci_print_info);
    2508                 :            : 
    2509                 :          0 : void ahci_set_em_messages(struct ahci_host_priv *hpriv,
    2510                 :            :                           struct ata_port_info *pi)
    2511                 :            : {
    2512                 :          0 :         u8 messages;
    2513                 :          0 :         void __iomem *mmio = hpriv->mmio;
    2514                 :          0 :         u32 em_loc = readl(mmio + HOST_EM_LOC);
    2515                 :          0 :         u32 em_ctl = readl(mmio + HOST_EM_CTL);
    2516                 :            : 
    2517   [ #  #  #  # ]:          0 :         if (!ahci_em_messages || !(hpriv->cap & HOST_CAP_EMS))
    2518                 :            :                 return;
    2519                 :            : 
    2520                 :          0 :         messages = (em_ctl & EM_CTRL_MSG_TYPE) >> 16;
    2521                 :            : 
    2522         [ #  # ]:          0 :         if (messages) {
    2523                 :            :                 /* store em_loc */
    2524                 :          0 :                 hpriv->em_loc = ((em_loc >> 16) * 4);
    2525                 :          0 :                 hpriv->em_buf_sz = ((em_loc & 0xff) * 4);
    2526                 :          0 :                 hpriv->em_msg_type = messages;
    2527                 :          0 :                 pi->flags |= ATA_FLAG_EM;
    2528         [ #  # ]:          0 :                 if (!(em_ctl & EM_CTL_ALHD))
    2529                 :          0 :                         pi->flags |= ATA_FLAG_SW_ACTIVITY;
    2530                 :            :         }
    2531                 :            : }
    2532                 :            : EXPORT_SYMBOL_GPL(ahci_set_em_messages);
    2533                 :            : 
    2534                 :          0 : static int ahci_host_activate_multi_irqs(struct ata_host *host,
    2535                 :            :                                          struct scsi_host_template *sht)
    2536                 :            : {
    2537                 :          0 :         struct ahci_host_priv *hpriv = host->private_data;
    2538                 :          0 :         int i, rc;
    2539                 :            : 
    2540                 :          0 :         rc = ata_host_start(host);
    2541         [ #  # ]:          0 :         if (rc)
    2542                 :            :                 return rc;
    2543                 :            :         /*
    2544                 :            :          * Requests IRQs according to AHCI-1.1 when multiple MSIs were
    2545                 :            :          * allocated. That is one MSI per port, starting from @irq.
    2546                 :            :          */
    2547         [ #  # ]:          0 :         for (i = 0; i < host->n_ports; i++) {
    2548                 :          0 :                 struct ahci_port_priv *pp = host->ports[i]->private_data;
    2549                 :          0 :                 int irq = hpriv->get_irq_vector(host, i);
    2550                 :            : 
    2551                 :            :                 /* Do not receive interrupts sent by dummy ports */
    2552         [ #  # ]:          0 :                 if (!pp) {
    2553                 :          0 :                         disable_irq(irq);
    2554                 :          0 :                         continue;
    2555                 :            :                 }
    2556                 :            : 
    2557                 :          0 :                 rc = devm_request_irq(host->dev, irq, ahci_multi_irqs_intr_hard,
    2558                 :          0 :                                 0, pp->irq_desc, host->ports[i]);
    2559                 :            : 
    2560         [ #  # ]:          0 :                 if (rc)
    2561                 :          0 :                         return rc;
    2562                 :          0 :                 ata_port_desc(host->ports[i], "irq %d", irq);
    2563                 :            :         }
    2564                 :            : 
    2565                 :          0 :         return ata_host_register(host, sht);
    2566                 :            : }
    2567                 :            : 
    2568                 :            : /**
    2569                 :            :  *      ahci_host_activate - start AHCI host, request IRQs and register it
    2570                 :            :  *      @host: target ATA host
    2571                 :            :  *      @sht: scsi_host_template to use when registering the host
    2572                 :            :  *
    2573                 :            :  *      LOCKING:
    2574                 :            :  *      Inherited from calling layer (may sleep).
    2575                 :            :  *
    2576                 :            :  *      RETURNS:
    2577                 :            :  *      0 on success, -errno otherwise.
    2578                 :            :  */
    2579                 :          0 : int ahci_host_activate(struct ata_host *host, struct scsi_host_template *sht)
    2580                 :            : {
    2581                 :          0 :         struct ahci_host_priv *hpriv = host->private_data;
    2582                 :          0 :         int irq = hpriv->irq;
    2583                 :          0 :         int rc;
    2584                 :            : 
    2585         [ #  # ]:          0 :         if (hpriv->flags & AHCI_HFLAG_MULTI_MSI) {
    2586   [ #  #  #  # ]:          0 :                 if (hpriv->irq_handler &&
    2587                 :            :                     hpriv->irq_handler != ahci_single_level_irq_intr)
    2588                 :          0 :                         dev_warn(host->dev,
    2589                 :            :                                  "both AHCI_HFLAG_MULTI_MSI flag set and custom irq handler implemented\n");
    2590         [ #  # ]:          0 :                 if (!hpriv->get_irq_vector) {
    2591                 :          0 :                         dev_err(host->dev,
    2592                 :            :                                 "AHCI_HFLAG_MULTI_MSI requires ->get_irq_vector!\n");
    2593                 :          0 :                         return -EIO;
    2594                 :            :                 }
    2595                 :            : 
    2596                 :          0 :                 rc = ahci_host_activate_multi_irqs(host, sht);
    2597                 :            :         } else {
    2598                 :          0 :                 rc = ata_host_activate(host, irq, hpriv->irq_handler,
    2599                 :            :                                        IRQF_SHARED, sht);
    2600                 :            :         }
    2601                 :            : 
    2602                 :            : 
    2603                 :            :         return rc;
    2604                 :            : }
    2605                 :            : EXPORT_SYMBOL_GPL(ahci_host_activate);
    2606                 :            : 
    2607                 :            : MODULE_AUTHOR("Jeff Garzik");
    2608                 :            : MODULE_DESCRIPTION("Common AHCI SATA low-level routines");
    2609                 :            : MODULE_LICENSE("GPL");

Generated by: LCOV version 1.14