drivers/ata/libahci.c

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