drivers/ata/ahci.c

   1 /*
   2  *  ahci.c - AHCI SATA support
   3  *
   4  *  Maintained by:  Jeff Garzik <jgarzik@pobox.com>
   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/module.h>
  37 #include <linux/pci.h>
  38 #include <linux/init.h>
  39 #include <linux/blkdev.h>
  40 #include <linux/delay.h>
  41 #include <linux/interrupt.h>
  42 #include <linux/dma-mapping.h>
  43 #include <linux/device.h>
  44 #include <linux/dmi.h>
  45 #include <scsi/scsi_host.h>
  46 #include <scsi/scsi_cmnd.h>
  47 #include <linux/libata.h>
  48
  49 #define DRV_NAME        "ahci"
  50 #define DRV_VERSION     "3.0"
  51
  52 /* Enclosure Management Control */
  53 #define EM_CTRL_MSG_TYPE              0x000f0000
  54
  55 /* Enclosure Management LED Message Type */
  56 #define EM_MSG_LED_HBA_PORT           0x0000000f
  57 #define EM_MSG_LED_PMP_SLOT           0x0000ff00
  58 #define EM_MSG_LED_VALUE              0xffff0000
  59 #define EM_MSG_LED_VALUE_ACTIVITY     0x00070000
  60 #define EM_MSG_LED_VALUE_OFF          0xfff80000
  61 #define EM_MSG_LED_VALUE_ON           0x00010000
  62
  63 static int ahci_skip_host_reset;
  64 static int ahci_ignore_sss;
  65
  66 module_param_named(skip_host_reset, ahci_skip_host_reset, int, 0444);
  67 MODULE_PARM_DESC(skip_host_reset, "skip global host reset (0=don't skip, 1=skip)");
  68
  69 module_param_named(ignore_sss, ahci_ignore_sss, int, 0444);
  70 MODULE_PARM_DESC(ignore_sss, "Ignore staggered spinup flag (0=don't ignore, 1=ignore)");
  71
  72 static int ahci_enable_alpm(struct ata_port *ap,
  73                 enum link_pm policy);
  74 static void ahci_disable_alpm(struct ata_port *ap);
  75 static ssize_t ahci_led_show(struct ata_port *ap, char *buf);
  76 static ssize_t ahci_led_store(struct ata_port *ap, const char *buf,
  77                               size_t size);
  78 static ssize_t ahci_transmit_led_message(struct ata_port *ap, u32 state,
  79                                         ssize_t size);
  80
  81 enum {
  82         AHCI_PCI_BAR            = 5,
  83         AHCI_MAX_PORTS          = 32,
  84         AHCI_MAX_SG             = 168, /* hardware max is 64K */
  85         AHCI_DMA_BOUNDARY       = 0xffffffff,
  86         AHCI_MAX_CMDS           = 32,
  87         AHCI_CMD_SZ             = 32,
  88         AHCI_CMD_SLOT_SZ        = AHCI_MAX_CMDS * AHCI_CMD_SZ,
  89         AHCI_RX_FIS_SZ          = 256,
  90         AHCI_CMD_TBL_CDB        = 0x40,
  91         AHCI_CMD_TBL_HDR_SZ     = 0x80,
  92         AHCI_CMD_TBL_SZ         = AHCI_CMD_TBL_HDR_SZ + (AHCI_MAX_SG * 16),
  93         AHCI_CMD_TBL_AR_SZ      = AHCI_CMD_TBL_SZ * AHCI_MAX_CMDS,
  94         AHCI_PORT_PRIV_DMA_SZ   = AHCI_CMD_SLOT_SZ + AHCI_CMD_TBL_AR_SZ +
  95                                   AHCI_RX_FIS_SZ,
  96         AHCI_IRQ_ON_SG          = (1 << 31),
  97         AHCI_CMD_ATAPI          = (1 << 5),
  98         AHCI_CMD_WRITE          = (1 << 6),
  99         AHCI_CMD_PREFETCH       = (1 << 7),
 100         AHCI_CMD_RESET          = (1 << 8),
 101         AHCI_CMD_CLR_BUSY       = (1 << 10),
 102
 103         RX_FIS_D2H_REG          = 0x40, /* offset of D2H Register FIS data */
 104         RX_FIS_SDB              = 0x58, /* offset of SDB FIS data */
 105         RX_FIS_UNK              = 0x60, /* offset of Unknown FIS data */
 106
 107         board_ahci              = 0,
 108         board_ahci_vt8251       = 1,
 109         board_ahci_ign_iferr    = 2,
 110         board_ahci_sb600        = 3,
 111         board_ahci_mv           = 4,
 112         board_ahci_sb700        = 5, /* for SB700 and SB800 */
 113         board_ahci_mcp65        = 6,
 114         board_ahci_nopmp        = 7,
 115         board_ahci_yesncq       = 8,
 116
 117         /* global controller registers */
 118         HOST_CAP                = 0x00, /* host capabilities */
 119         HOST_CTL                = 0x04, /* global host control */
 120         HOST_IRQ_STAT           = 0x08, /* interrupt status */
 121         HOST_PORTS_IMPL         = 0x0c, /* bitmap of implemented ports */
 122         HOST_VERSION            = 0x10, /* AHCI spec. version compliancy */
 123         HOST_EM_LOC             = 0x1c, /* Enclosure Management location */
 124         HOST_EM_CTL             = 0x20, /* Enclosure Management Control */
 125
 126         /* HOST_CTL bits */
 127         HOST_RESET              = (1 << 0),  /* reset controller; self-clear */
 128         HOST_IRQ_EN             = (1 << 1),  /* global IRQ enable */
 129         HOST_AHCI_EN            = (1 << 31), /* AHCI enabled */
 130
 131         /* HOST_CAP bits */
 132         HOST_CAP_EMS            = (1 << 6),  /* Enclosure Management support */
 133         HOST_CAP_SSC            = (1 << 14), /* Slumber capable */
 134         HOST_CAP_PMP            = (1 << 17), /* Port Multiplier support */
 135         HOST_CAP_CLO            = (1 << 24), /* Command List Override support */
 136         HOST_CAP_ALPM           = (1 << 26), /* Aggressive Link PM support */
 137         HOST_CAP_SSS            = (1 << 27), /* Staggered Spin-up */
 138         HOST_CAP_SNTF           = (1 << 29), /* SNotification register */
 139         HOST_CAP_NCQ            = (1 << 30), /* Native Command Queueing */
 140         HOST_CAP_64             = (1 << 31), /* PCI DAC (64-bit DMA) support */
 141
 142         /* registers for each SATA port */
 143         PORT_LST_ADDR           = 0x00, /* command list DMA addr */
 144         PORT_LST_ADDR_HI        = 0x04, /* command list DMA addr hi */
 145         PORT_FIS_ADDR           = 0x08, /* FIS rx buf addr */
 146         PORT_FIS_ADDR_HI        = 0x0c, /* FIS rx buf addr hi */
 147         PORT_IRQ_STAT           = 0x10, /* interrupt status */
 148         PORT_IRQ_MASK           = 0x14, /* interrupt enable/disable mask */
 149         PORT_CMD                = 0x18, /* port command */
 150         PORT_TFDATA             = 0x20, /* taskfile data */
 151         PORT_SIG                = 0x24, /* device TF signature */
 152         PORT_CMD_ISSUE          = 0x38, /* command issue */
 153         PORT_SCR_STAT           = 0x28, /* SATA phy register: SStatus */
 154         PORT_SCR_CTL            = 0x2c, /* SATA phy register: SControl */
 155         PORT_SCR_ERR            = 0x30, /* SATA phy register: SError */
 156         PORT_SCR_ACT            = 0x34, /* SATA phy register: SActive */
 157         PORT_SCR_NTF            = 0x3c, /* SATA phy register: SNotification */
 158
 159         /* PORT_IRQ_{STAT,MASK} bits */
 160         PORT_IRQ_COLD_PRES      = (1 << 31), /* cold presence detect */
 161         PORT_IRQ_TF_ERR         = (1 << 30), /* task file error */
 162         PORT_IRQ_HBUS_ERR       = (1 << 29), /* host bus fatal error */
 163         PORT_IRQ_HBUS_DATA_ERR  = (1 << 28), /* host bus data error */
 164         PORT_IRQ_IF_ERR         = (1 << 27), /* interface fatal error */
 165         PORT_IRQ_IF_NONFATAL    = (1 << 26), /* interface non-fatal error */
 166         PORT_IRQ_OVERFLOW       = (1 << 24), /* xfer exhausted available S/G */
 167         PORT_IRQ_BAD_PMP        = (1 << 23), /* incorrect port multiplier */
 168
 169         PORT_IRQ_PHYRDY         = (1 << 22), /* PhyRdy changed */
 170         PORT_IRQ_DEV_ILCK       = (1 << 7), /* device interlock */
 171         PORT_IRQ_CONNECT        = (1 << 6), /* port connect change status */
 172         PORT_IRQ_SG_DONE        = (1 << 5), /* descriptor processed */
 173         PORT_IRQ_UNK_FIS        = (1 << 4), /* unknown FIS rx'd */
 174         PORT_IRQ_SDB_FIS        = (1 << 3), /* Set Device Bits FIS rx'd */
 175         PORT_IRQ_DMAS_FIS       = (1 << 2), /* DMA Setup FIS rx'd */
 176         PORT_IRQ_PIOS_FIS       = (1 << 1), /* PIO Setup FIS rx'd */
 177         PORT_IRQ_D2H_REG_FIS    = (1 << 0), /* D2H Register FIS rx'd */
 178
 179         PORT_IRQ_FREEZE         = PORT_IRQ_HBUS_ERR |
 180                                   PORT_IRQ_IF_ERR |
 181                                   PORT_IRQ_CONNECT |
 182                                   PORT_IRQ_PHYRDY |
 183                                   PORT_IRQ_UNK_FIS |
 184                                   PORT_IRQ_BAD_PMP,
 185         PORT_IRQ_ERROR          = PORT_IRQ_FREEZE |
 186                                   PORT_IRQ_TF_ERR |
 187                                   PORT_IRQ_HBUS_DATA_ERR,
 188         DEF_PORT_IRQ            = PORT_IRQ_ERROR | PORT_IRQ_SG_DONE |
 189                                   PORT_IRQ_SDB_FIS | PORT_IRQ_DMAS_FIS |
 190                                   PORT_IRQ_PIOS_FIS | PORT_IRQ_D2H_REG_FIS,
 191
 192         /* PORT_CMD bits */
 193         PORT_CMD_ASP            = (1 << 27), /* Aggressive Slumber/Partial */
 194         PORT_CMD_ALPE           = (1 << 26), /* Aggressive Link PM enable */
 195         PORT_CMD_ATAPI          = (1 << 24), /* Device is ATAPI */
 196         PORT_CMD_PMP            = (1 << 17), /* PMP attached */
 197         PORT_CMD_LIST_ON        = (1 << 15), /* cmd list DMA engine running */
 198         PORT_CMD_FIS_ON         = (1 << 14), /* FIS DMA engine running */
 199         PORT_CMD_FIS_RX         = (1 << 4), /* Enable FIS receive DMA engine */
 200         PORT_CMD_CLO            = (1 << 3), /* Command list override */
 201         PORT_CMD_POWER_ON       = (1 << 2), /* Power up device */
 202         PORT_CMD_SPIN_UP        = (1 << 1), /* Spin up device */
 203         PORT_CMD_START          = (1 << 0), /* Enable port DMA engine */
 204
 205         PORT_CMD_ICC_MASK       = (0xf << 28), /* i/f ICC state mask */
 206         PORT_CMD_ICC_ACTIVE     = (0x1 << 28), /* Put i/f in active state */
 207         PORT_CMD_ICC_PARTIAL    = (0x2 << 28), /* Put i/f in partial state */
 208         PORT_CMD_ICC_SLUMBER    = (0x6 << 28), /* Put i/f in slumber state */
 209
 210         /* hpriv->flags bits */
 211         AHCI_HFLAG_NO_NCQ               = (1 << 0),
 212         AHCI_HFLAG_IGN_IRQ_IF_ERR       = (1 << 1), /* ignore IRQ_IF_ERR */
 213         AHCI_HFLAG_IGN_SERR_INTERNAL    = (1 << 2), /* ignore SERR_INTERNAL */
 214         AHCI_HFLAG_32BIT_ONLY           = (1 << 3), /* force 32bit */
 215         AHCI_HFLAG_MV_PATA              = (1 << 4), /* PATA port */
 216         AHCI_HFLAG_NO_MSI               = (1 << 5), /* no PCI MSI */
 217         AHCI_HFLAG_NO_PMP               = (1 << 6), /* no PMP */
 218         AHCI_HFLAG_NO_HOTPLUG           = (1 << 7), /* ignore PxSERR.DIAG.N */
 219         AHCI_HFLAG_SECT255              = (1 << 8), /* max 255 sectors */
 220         AHCI_HFLAG_YES_NCQ              = (1 << 9), /* force NCQ cap on */
 221         AHCI_HFLAG_NO_SUSPEND           = (1 << 10), /* don't suspend */
 222
 223         /* ap->flags bits */
 224
 225         AHCI_FLAG_COMMON                = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
 226                                           ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA |
 227                                           ATA_FLAG_ACPI_SATA | ATA_FLAG_AN |
 228                                           ATA_FLAG_IPM,
 229
 230         ICH_MAP                         = 0x90, /* ICH MAP register */
 231
 232         /* em constants */
 233         EM_MAX_SLOTS                    = 8,
 234         EM_MAX_RETRY                    = 5,
 235
 236         /* em_ctl bits */
 237         EM_CTL_RST                      = (1 << 9), /* Reset */
 238         EM_CTL_TM                       = (1 << 8), /* Transmit Message */
 239         EM_CTL_ALHD                     = (1 << 26), /* Activity LED */
 240 };
 241
 242 struct ahci_cmd_hdr {
 243         __le32                  opts;
 244         __le32                  status;
 245         __le32                  tbl_addr;
 246         __le32                  tbl_addr_hi;
 247         __le32                  reserved[4];
 248 };
 249
 250 struct ahci_sg {
 251         __le32                  addr;
 252         __le32                  addr_hi;
 253         __le32                  reserved;
 254         __le32                  flags_size;
 255 };
 256
 257 struct ahci_em_priv {
 258         enum sw_activity blink_policy;
 259         struct timer_list timer;
 260         unsigned long saved_activity;
 261         unsigned long activity;
 262         unsigned long led_state;
 263 };
 264
 265 struct ahci_host_priv {
 266         unsigned int            flags;          /* AHCI_HFLAG_* */
 267         u32                     cap;            /* cap to use */
 268         u32                     port_map;       /* port map to use */
 269         u32                     saved_cap;      /* saved initial cap */
 270         u32                     saved_port_map; /* saved initial port_map */
 271         u32                     em_loc; /* enclosure management location */
 272 };
 273
 274 struct ahci_port_priv {
 275         struct ata_link         *active_link;
 276         struct ahci_cmd_hdr     *cmd_slot;
 277         dma_addr_t              cmd_slot_dma;
 278         void                    *cmd_tbl;
 279         dma_addr_t              cmd_tbl_dma;
 280         void                    *rx_fis;
 281         dma_addr_t              rx_fis_dma;
 282         /* for NCQ spurious interrupt analysis */
 283         unsigned int            ncq_saw_d2h:1;
 284         unsigned int            ncq_saw_dmas:1;
 285         unsigned int            ncq_saw_sdb:1;
 286         u32                     intr_mask;      /* interrupts to enable */
 287         /* enclosure management info per PM slot */
 288         struct ahci_em_priv     em_priv[EM_MAX_SLOTS];
 289 };
 290
 291 static int ahci_scr_read(struct ata_link *link, unsigned int sc_reg, u32 *val);
 292 static int ahci_scr_write(struct ata_link *link, unsigned int sc_reg, u32 val);
 293 static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
 294 static unsigned int ahci_qc_issue(struct ata_queued_cmd *qc);
 295 static bool ahci_qc_fill_rtf(struct ata_queued_cmd *qc);
 296 static int ahci_port_start(struct ata_port *ap);
 297 static void ahci_port_stop(struct ata_port *ap);
 298 static void ahci_qc_prep(struct ata_queued_cmd *qc);
 299 static void ahci_freeze(struct ata_port *ap);
 300 static void ahci_thaw(struct ata_port *ap);
 301 static void ahci_pmp_attach(struct ata_port *ap);
 302 static void ahci_pmp_detach(struct ata_port *ap);
 303 static int ahci_softreset(struct ata_link *link, unsigned int *class,
 304                           unsigned long deadline);
 305 static int ahci_sb600_softreset(struct ata_link *link, unsigned int *class,
 306                           unsigned long deadline);
 307 static int ahci_hardreset(struct ata_link *link, unsigned int *class,
 308                           unsigned long deadline);
 309 static int ahci_vt8251_hardreset(struct ata_link *link, unsigned int *class,
 310                                  unsigned long deadline);
 311 static int ahci_p5wdh_hardreset(struct ata_link *link, unsigned int *class,
 312                                 unsigned long deadline);
 313 static void ahci_postreset(struct ata_link *link, unsigned int *class);
 314 static void ahci_error_handler(struct ata_port *ap);
 315 static void ahci_post_internal_cmd(struct ata_queued_cmd *qc);
 316 static int ahci_port_resume(struct ata_port *ap);
 317 static void ahci_dev_config(struct ata_device *dev);
 318 static void ahci_fill_cmd_slot(struct ahci_port_priv *pp, unsigned int tag,
 319                                u32 opts);
 320 #ifdef CONFIG_PM
 321 static int ahci_port_suspend(struct ata_port *ap, pm_message_t mesg);
 322 static int ahci_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg);
 323 static int ahci_pci_device_resume(struct pci_dev *pdev);
 324 #endif
 325 static ssize_t ahci_activity_show(struct ata_device *dev, char *buf);
 326 static ssize_t ahci_activity_store(struct ata_device *dev,
 327                                    enum sw_activity val);
 328 static void ahci_init_sw_activity(struct ata_link *link);
 329
 330 static struct device_attribute *ahci_shost_attrs[] = {
 331         &dev_attr_link_power_management_policy,
 332         &dev_attr_em_message_type,
 333         &dev_attr_em_message,
 334         NULL
 335 };
 336
 337 static struct device_attribute *ahci_sdev_attrs[] = {
 338         &dev_attr_sw_activity,
 339         &dev_attr_unload_heads,
 340         NULL
 341 };
 342
 343 static struct scsi_host_template ahci_sht = {
 344         ATA_NCQ_SHT(DRV_NAME),
 345         .can_queue              = AHCI_MAX_CMDS - 1,
 346         .sg_tablesize           = AHCI_MAX_SG,
 347         .dma_boundary           = AHCI_DMA_BOUNDARY,
 348         .shost_attrs            = ahci_shost_attrs,
 349         .sdev_attrs             = ahci_sdev_attrs,
 350 };
 351
 352 static struct ata_port_operations ahci_ops = {
 353         .inherits               = &sata_pmp_port_ops,
 354
 355         .qc_defer               = sata_pmp_qc_defer_cmd_switch,
 356         .qc_prep                = ahci_qc_prep,
 357         .qc_issue               = ahci_qc_issue,
 358         .qc_fill_rtf            = ahci_qc_fill_rtf,
 359
 360         .freeze                 = ahci_freeze,
 361         .thaw                   = ahci_thaw,
 362         .softreset              = ahci_softreset,
 363         .hardreset              = ahci_hardreset,
 364         .postreset              = ahci_postreset,
 365         .pmp_softreset          = ahci_softreset,
 366         .error_handler          = ahci_error_handler,
 367         .post_internal_cmd      = ahci_post_internal_cmd,
 368         .dev_config             = ahci_dev_config,
 369
 370         .scr_read               = ahci_scr_read,
 371         .scr_write              = ahci_scr_write,
 372         .pmp_attach             = ahci_pmp_attach,
 373         .pmp_detach             = ahci_pmp_detach,
 374
 375         .enable_pm              = ahci_enable_alpm,
 376         .disable_pm             = ahci_disable_alpm,
 377         .em_show                = ahci_led_show,
 378         .em_store               = ahci_led_store,
 379         .sw_activity_show       = ahci_activity_show,
 380         .sw_activity_store      = ahci_activity_store,
 381 #ifdef CONFIG_PM
 382         .port_suspend           = ahci_port_suspend,
 383         .port_resume            = ahci_port_resume,
 384 #endif
 385         .port_start             = ahci_port_start,
 386         .port_stop              = ahci_port_stop,
 387 };
 388
 389 static struct ata_port_operations ahci_vt8251_ops = {
 390         .inherits               = &ahci_ops,
 391         .hardreset              = ahci_vt8251_hardreset,
 392 };
 393
 394 static struct ata_port_operations ahci_p5wdh_ops = {
 395         .inherits               = &ahci_ops,
 396         .hardreset              = ahci_p5wdh_hardreset,
 397 };
 398
 399 static struct ata_port_operations ahci_sb600_ops = {
 400         .inherits               = &ahci_ops,
 401         .softreset              = ahci_sb600_softreset,
 402         .pmp_softreset          = ahci_sb600_softreset,
 403 };
 404
 405 #define AHCI_HFLAGS(flags)      .private_data   = (void *)(flags)
 406
 407 static const struct ata_port_info ahci_port_info[] = {
 408         [board_ahci] =
 409         {
 410                 .flags          = AHCI_FLAG_COMMON,
 411                 .pio_mask       = ATA_PIO4,
 412                 .udma_mask      = ATA_UDMA6,
 413                 .port_ops       = &ahci_ops,
 414         },
 415         [board_ahci_vt8251] =
 416         {
 417                 AHCI_HFLAGS     (AHCI_HFLAG_NO_NCQ | AHCI_HFLAG_NO_PMP),
 418                 .flags          = AHCI_FLAG_COMMON,
 419                 .pio_mask       = ATA_PIO4,
 420                 .udma_mask      = ATA_UDMA6,
 421                 .port_ops       = &ahci_vt8251_ops,
 422         },
 423         [board_ahci_ign_iferr] =
 424         {
 425                 AHCI_HFLAGS     (AHCI_HFLAG_IGN_IRQ_IF_ERR),
 426                 .flags          = AHCI_FLAG_COMMON,
 427                 .pio_mask       = ATA_PIO4,
 428                 .udma_mask      = ATA_UDMA6,
 429                 .port_ops       = &ahci_ops,
 430         },
 431         [board_ahci_sb600] =
 432         {
 433                 AHCI_HFLAGS     (AHCI_HFLAG_IGN_SERR_INTERNAL |
 434                                  AHCI_HFLAG_NO_MSI | AHCI_HFLAG_SECT255),
 435                 .flags          = AHCI_FLAG_COMMON,
 436                 .pio_mask       = ATA_PIO4,
 437                 .udma_mask      = ATA_UDMA6,
 438                 .port_ops       = &ahci_sb600_ops,
 439         },
 440         [board_ahci_mv] =
 441         {
 442                 AHCI_HFLAGS     (AHCI_HFLAG_NO_NCQ | AHCI_HFLAG_NO_MSI |
 443                                  AHCI_HFLAG_MV_PATA | AHCI_HFLAG_NO_PMP),
 444                 .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
 445                                   ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA,
 446                 .pio_mask       = ATA_PIO4,
 447                 .udma_mask      = ATA_UDMA6,
 448                 .port_ops       = &ahci_ops,
 449         },
 450         [board_ahci_sb700] =    /* for SB700 and SB800 */
 451         {
 452                 AHCI_HFLAGS     (AHCI_HFLAG_IGN_SERR_INTERNAL),
 453                 .flags          = AHCI_FLAG_COMMON,
 454                 .pio_mask       = ATA_PIO4,
 455                 .udma_mask      = ATA_UDMA6,
 456                 .port_ops       = &ahci_sb600_ops,
 457         },
 458         [board_ahci_mcp65] =
 459         {
 460                 AHCI_HFLAGS     (AHCI_HFLAG_YES_NCQ),
 461                 .flags          = AHCI_FLAG_COMMON,
 462                 .pio_mask       = ATA_PIO4,
 463                 .udma_mask      = ATA_UDMA6,
 464                 .port_ops       = &ahci_ops,
 465         },
 466         [board_ahci_nopmp] =
 467         {
 468                 AHCI_HFLAGS     (AHCI_HFLAG_NO_PMP),
 469                 .flags          = AHCI_FLAG_COMMON,
 470                 .pio_mask       = ATA_PIO4,
 471                 .udma_mask      = ATA_UDMA6,
 472                 .port_ops       = &ahci_ops,
 473         },
 474         /* board_ahci_yesncq */
 475         {
 476                 AHCI_HFLAGS     (AHCI_HFLAG_YES_NCQ),
 477                 .flags          = AHCI_FLAG_COMMON,
 478                 .pio_mask       = ATA_PIO4,
 479                 .udma_mask      = ATA_UDMA6,
 480                 .port_ops       = &ahci_ops,
 481         },
 482 };
 483
 484 static const struct pci_device_id ahci_pci_tbl[] = {
 485         /* Intel */
 486         { PCI_VDEVICE(INTEL, 0x2652), board_ahci }, /* ICH6 */
 487         { PCI_VDEVICE(INTEL, 0x2653), board_ahci }, /* ICH6M */
 488         { PCI_VDEVICE(INTEL, 0x27c1), board_ahci }, /* ICH7 */
 489         { PCI_VDEVICE(INTEL, 0x27c5), board_ahci }, /* ICH7M */
 490         { PCI_VDEVICE(INTEL, 0x27c3), board_ahci }, /* ICH7R */
 491         { PCI_VDEVICE(AL, 0x5288), board_ahci_ign_iferr }, /* ULi M5288 */
 492         { PCI_VDEVICE(INTEL, 0x2681), board_ahci }, /* ESB2 */
 493         { PCI_VDEVICE(INTEL, 0x2682), board_ahci }, /* ESB2 */
 494         { PCI_VDEVICE(INTEL, 0x2683), board_ahci }, /* ESB2 */
 495         { PCI_VDEVICE(INTEL, 0x27c6), board_ahci }, /* ICH7-M DH */
 496         { PCI_VDEVICE(INTEL, 0x2821), board_ahci }, /* ICH8 */
 497         { PCI_VDEVICE(INTEL, 0x2822), board_ahci }, /* ICH8 */
 498         { PCI_VDEVICE(INTEL, 0x2824), board_ahci }, /* ICH8 */
 499         { PCI_VDEVICE(INTEL, 0x2829), board_ahci }, /* ICH8M */
 500         { PCI_VDEVICE(INTEL, 0x282a), board_ahci }, /* ICH8M */
 501         { PCI_VDEVICE(INTEL, 0x2922), board_ahci }, /* ICH9 */
 502         { PCI_VDEVICE(INTEL, 0x2923), board_ahci }, /* ICH9 */
 503         { PCI_VDEVICE(INTEL, 0x2924), board_ahci }, /* ICH9 */
 504         { PCI_VDEVICE(INTEL, 0x2925), board_ahci }, /* ICH9 */
 505         { PCI_VDEVICE(INTEL, 0x2927), board_ahci }, /* ICH9 */
 506         { PCI_VDEVICE(INTEL, 0x2929), board_ahci }, /* ICH9M */
 507         { PCI_VDEVICE(INTEL, 0x292a), board_ahci }, /* ICH9M */
 508         { PCI_VDEVICE(INTEL, 0x292b), board_ahci }, /* ICH9M */
 509         { PCI_VDEVICE(INTEL, 0x292c), board_ahci }, /* ICH9M */
 510         { PCI_VDEVICE(INTEL, 0x292f), board_ahci }, /* ICH9M */
 511         { PCI_VDEVICE(INTEL, 0x294d), board_ahci }, /* ICH9 */
 512         { PCI_VDEVICE(INTEL, 0x294e), board_ahci }, /* ICH9M */
 513         { PCI_VDEVICE(INTEL, 0x502a), board_ahci }, /* Tolapai */
 514         { PCI_VDEVICE(INTEL, 0x502b), board_ahci }, /* Tolapai */
 515         { PCI_VDEVICE(INTEL, 0x3a05), board_ahci }, /* ICH10 */
 516         { PCI_VDEVICE(INTEL, 0x3a22), board_ahci }, /* ICH10 */
 517         { PCI_VDEVICE(INTEL, 0x3a25), board_ahci }, /* ICH10 */
 518         { PCI_VDEVICE(INTEL, 0x3b22), board_ahci }, /* PCH AHCI */
 519         { PCI_VDEVICE(INTEL, 0x3b23), board_ahci }, /* PCH AHCI */
 520         { PCI_VDEVICE(INTEL, 0x3b24), board_ahci }, /* PCH RAID */
 521         { PCI_VDEVICE(INTEL, 0x3b25), board_ahci }, /* PCH RAID */
 522         { PCI_VDEVICE(INTEL, 0x3b29), board_ahci }, /* PCH AHCI */
 523         { PCI_VDEVICE(INTEL, 0x3b2b), board_ahci }, /* PCH RAID */
 524         { PCI_VDEVICE(INTEL, 0x3b2c), board_ahci }, /* PCH RAID */
 525         { PCI_VDEVICE(INTEL, 0x3b2f), board_ahci }, /* PCH AHCI */
 526
 527         /* JMicron 360/1/3/5/6, match class to avoid IDE function */
 528         { PCI_VENDOR_ID_JMICRON, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,
 529           PCI_CLASS_STORAGE_SATA_AHCI, 0xffffff, board_ahci_ign_iferr },
 530
 531         /* ATI */
 532         { PCI_VDEVICE(ATI, 0x4380), board_ahci_sb600 }, /* ATI SB600 */
 533         { PCI_VDEVICE(ATI, 0x4390), board_ahci_sb700 }, /* ATI SB700/800 */
 534         { PCI_VDEVICE(ATI, 0x4391), board_ahci_sb700 }, /* ATI SB700/800 */
 535         { PCI_VDEVICE(ATI, 0x4392), board_ahci_sb700 }, /* ATI SB700/800 */
 536         { PCI_VDEVICE(ATI, 0x4393), board_ahci_sb700 }, /* ATI SB700/800 */
 537         { PCI_VDEVICE(ATI, 0x4394), board_ahci_sb700 }, /* ATI SB700/800 */
 538         { PCI_VDEVICE(ATI, 0x4395), board_ahci_sb700 }, /* ATI SB700/800 */
 539
 540         /* VIA */
 541         { PCI_VDEVICE(VIA, 0x3349), board_ahci_vt8251 }, /* VIA VT8251 */
 542         { PCI_VDEVICE(VIA, 0x6287), board_ahci_vt8251 }, /* VIA VT8251 */
 543
 544         /* NVIDIA */
 545         { PCI_VDEVICE(NVIDIA, 0x044c), board_ahci_mcp65 },      /* MCP65 */
 546         { PCI_VDEVICE(NVIDIA, 0x044d), board_ahci_mcp65 },      /* MCP65 */
 547         { PCI_VDEVICE(NVIDIA, 0x044e), board_ahci_mcp65 },      /* MCP65 */
 548         { PCI_VDEVICE(NVIDIA, 0x044f), board_ahci_mcp65 },      /* MCP65 */
 549         { PCI_VDEVICE(NVIDIA, 0x045c), board_ahci_mcp65 },      /* MCP65 */
 550         { PCI_VDEVICE(NVIDIA, 0x045d), board_ahci_mcp65 },      /* MCP65 */
 551         { PCI_VDEVICE(NVIDIA, 0x045e), board_ahci_mcp65 },      /* MCP65 */
 552         { PCI_VDEVICE(NVIDIA, 0x045f), board_ahci_mcp65 },      /* MCP65 */
 553         { PCI_VDEVICE(NVIDIA, 0x0550), board_ahci_yesncq },     /* MCP67 */
 554         { PCI_VDEVICE(NVIDIA, 0x0551), board_ahci_yesncq },     /* MCP67 */
 555         { PCI_VDEVICE(NVIDIA, 0x0552), board_ahci_yesncq },     /* MCP67 */
 556         { PCI_VDEVICE(NVIDIA, 0x0553), board_ahci_yesncq },     /* MCP67 */
 557         { PCI_VDEVICE(NVIDIA, 0x0554), board_ahci_yesncq },     /* MCP67 */
 558         { PCI_VDEVICE(NVIDIA, 0x0555), board_ahci_yesncq },     /* MCP67 */
 559         { PCI_VDEVICE(NVIDIA, 0x0556), board_ahci_yesncq },     /* MCP67 */
 560         { PCI_VDEVICE(NVIDIA, 0x0557), board_ahci_yesncq },     /* MCP67 */
 561         { PCI_VDEVICE(NVIDIA, 0x0558), board_ahci_yesncq },     /* MCP67 */
 562         { PCI_VDEVICE(NVIDIA, 0x0559), board_ahci_yesncq },     /* MCP67 */
 563         { PCI_VDEVICE(NVIDIA, 0x055a), board_ahci_yesncq },     /* MCP67 */
 564         { PCI_VDEVICE(NVIDIA, 0x055b), board_ahci_yesncq },     /* MCP67 */
 565         { PCI_VDEVICE(NVIDIA, 0x07f0), board_ahci_yesncq },     /* MCP73 */
 566         { PCI_VDEVICE(NVIDIA, 0x07f1), board_ahci_yesncq },     /* MCP73 */
 567         { PCI_VDEVICE(NVIDIA, 0x07f2), board_ahci_yesncq },     /* MCP73 */
 568         { PCI_VDEVICE(NVIDIA, 0x07f3), board_ahci_yesncq },     /* MCP73 */
 569         { PCI_VDEVICE(NVIDIA, 0x07f4), board_ahci_yesncq },     /* MCP73 */
 570         { PCI_VDEVICE(NVIDIA, 0x07f5), board_ahci_yesncq },     /* MCP73 */
 571         { PCI_VDEVICE(NVIDIA, 0x07f6), board_ahci_yesncq },     /* MCP73 */
 572         { PCI_VDEVICE(NVIDIA, 0x07f7), board_ahci_yesncq },     /* MCP73 */
 573         { PCI_VDEVICE(NVIDIA, 0x07f8), board_ahci_yesncq },     /* MCP73 */
 574         { PCI_VDEVICE(NVIDIA, 0x07f9), board_ahci_yesncq },     /* MCP73 */
 575         { PCI_VDEVICE(NVIDIA, 0x07fa), board_ahci_yesncq },     /* MCP73 */
 576         { PCI_VDEVICE(NVIDIA, 0x07fb), board_ahci_yesncq },     /* MCP73 */
 577         { PCI_VDEVICE(NVIDIA, 0x0ad0), board_ahci },            /* MCP77 */
 578         { PCI_VDEVICE(NVIDIA, 0x0ad1), board_ahci },            /* MCP77 */
 579         { PCI_VDEVICE(NVIDIA, 0x0ad2), board_ahci },            /* MCP77 */
 580         { PCI_VDEVICE(NVIDIA, 0x0ad3), board_ahci },            /* MCP77 */
 581         { PCI_VDEVICE(NVIDIA, 0x0ad4), board_ahci },            /* MCP77 */
 582         { PCI_VDEVICE(NVIDIA, 0x0ad5), board_ahci },            /* MCP77 */
 583         { PCI_VDEVICE(NVIDIA, 0x0ad6), board_ahci },            /* MCP77 */
 584         { PCI_VDEVICE(NVIDIA, 0x0ad7), board_ahci },            /* MCP77 */
 585         { PCI_VDEVICE(NVIDIA, 0x0ad8), board_ahci },            /* MCP77 */
 586         { PCI_VDEVICE(NVIDIA, 0x0ad9), board_ahci },            /* MCP77 */
 587         { PCI_VDEVICE(NVIDIA, 0x0ada), board_ahci },            /* MCP77 */
 588         { PCI_VDEVICE(NVIDIA, 0x0adb), board_ahci },            /* MCP77 */
 589         { PCI_VDEVICE(NVIDIA, 0x0ab4), board_ahci },            /* MCP79 */
 590         { PCI_VDEVICE(NVIDIA, 0x0ab5), board_ahci },            /* MCP79 */
 591         { PCI_VDEVICE(NVIDIA, 0x0ab6), board_ahci },            /* MCP79 */
 592         { PCI_VDEVICE(NVIDIA, 0x0ab7), board_ahci },            /* MCP79 */
 593         { PCI_VDEVICE(NVIDIA, 0x0ab8), board_ahci },            /* MCP79 */
 594         { PCI_VDEVICE(NVIDIA, 0x0ab9), board_ahci },            /* MCP79 */
 595         { PCI_VDEVICE(NVIDIA, 0x0aba), board_ahci },            /* MCP79 */
 596         { PCI_VDEVICE(NVIDIA, 0x0abb), board_ahci },            /* MCP79 */
 597         { PCI_VDEVICE(NVIDIA, 0x0abc), board_ahci },            /* MCP79 */
 598         { PCI_VDEVICE(NVIDIA, 0x0abd), board_ahci },            /* MCP79 */
 599         { PCI_VDEVICE(NVIDIA, 0x0abe), board_ahci },            /* MCP79 */
 600         { PCI_VDEVICE(NVIDIA, 0x0abf), board_ahci },            /* MCP79 */
 601         { PCI_VDEVICE(NVIDIA, 0x0d84), board_ahci },            /* MCP89 */
 602         { PCI_VDEVICE(NVIDIA, 0x0d85), board_ahci },            /* MCP89 */
 603         { PCI_VDEVICE(NVIDIA, 0x0d86), board_ahci },            /* MCP89 */
 604         { PCI_VDEVICE(NVIDIA, 0x0d87), board_ahci },            /* MCP89 */
 605         { PCI_VDEVICE(NVIDIA, 0x0d88), board_ahci },            /* MCP89 */
 606         { PCI_VDEVICE(NVIDIA, 0x0d89), board_ahci },            /* MCP89 */
 607         { PCI_VDEVICE(NVIDIA, 0x0d8a), board_ahci },            /* MCP89 */
 608         { PCI_VDEVICE(NVIDIA, 0x0d8b), board_ahci },            /* MCP89 */
 609         { PCI_VDEVICE(NVIDIA, 0x0d8c), board_ahci },            /* MCP89 */
 610         { PCI_VDEVICE(NVIDIA, 0x0d8d), board_ahci },            /* MCP89 */
 611         { PCI_VDEVICE(NVIDIA, 0x0d8e), board_ahci },            /* MCP89 */
 612         { PCI_VDEVICE(NVIDIA, 0x0d8f), board_ahci },            /* MCP89 */
 613
 614         /* SiS */
 615         { PCI_VDEVICE(SI, 0x1184), board_ahci },                /* SiS 966 */
 616         { PCI_VDEVICE(SI, 0x1185), board_ahci },                /* SiS 968 */
 617         { PCI_VDEVICE(SI, 0x0186), board_ahci },                /* SiS 968 */
 618
 619         /* Marvell */
 620         { PCI_VDEVICE(MARVELL, 0x6145), board_ahci_mv },        /* 6145 */
 621         { PCI_VDEVICE(MARVELL, 0x6121), board_ahci_mv },        /* 6121 */
 622
 623         /* Promise */
 624         { PCI_VDEVICE(PROMISE, 0x3f20), board_ahci },   /* PDC42819 */
 625
 626         /* Generic, PCI class code for AHCI */
 627         { PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,
 628           PCI_CLASS_STORAGE_SATA_AHCI, 0xffffff, board_ahci },
 629
 630         { }     /* terminate list */
 631 };
 632
 633
 634 static struct pci_driver ahci_pci_driver = {
 635         .name                   = DRV_NAME,
 636         .id_table               = ahci_pci_tbl,
 637         .probe                  = ahci_init_one,
 638         .remove                 = ata_pci_remove_one,
 639 #ifdef CONFIG_PM
 640         .suspend                = ahci_pci_device_suspend,
 641         .resume                 = ahci_pci_device_resume,
 642 #endif
 643 };
 644
 645 static int ahci_em_messages = 1;
 646 module_param(ahci_em_messages, int, 0444);
 647 /* add other LED protocol types when they become supported */
 648 MODULE_PARM_DESC(ahci_em_messages,
 649         "Set AHCI Enclosure Management Message type (0 = disabled, 1 = LED");
 650
 651 #if defined(CONFIG_PATA_MARVELL) || defined(CONFIG_PATA_MARVELL_MODULE)
 652 static int marvell_enable;
 653 #else
 654 static int marvell_enable = 1;
 655 #endif
 656 module_param(marvell_enable, int, 0644);
 657 MODULE_PARM_DESC(marvell_enable, "Marvell SATA via AHCI (1 = enabled)");
 658
 659
 660 static inline int ahci_nr_ports(u32 cap)
 661 {
 662         return (cap & 0x1f) + 1;
 663 }
 664
 665 static inline void __iomem *__ahci_port_base(struct ata_host *host,
 666                                              unsigned int port_no)
 667 {
 668         void __iomem *mmio = host->iomap[AHCI_PCI_BAR];
 669
 670         return mmio + 0x100 + (port_no * 0x80);
 671 }
 672
 673 static inline void __iomem *ahci_port_base(struct ata_port *ap)
 674 {
 675         return __ahci_port_base(ap->host, ap->port_no);
 676 }
 677
 678 static void ahci_enable_ahci(void __iomem *mmio)
 679 {
 680         int i;
 681         u32 tmp;
 682
 683         /* turn on AHCI_EN */
 684         tmp = readl(mmio + HOST_CTL);
 685         if (tmp & HOST_AHCI_EN)
 686                 return;
 687
 688         /* Some controllers need AHCI_EN to be written multiple times.
 689          * Try a few times before giving up.
 690          */
 691         for (i = 0; i < 5; i++) {
 692                 tmp |= HOST_AHCI_EN;
 693                 writel(tmp, mmio + HOST_CTL);
 694                 tmp = readl(mmio + HOST_CTL);   /* flush && sanity check */
 695                 if (tmp & HOST_AHCI_EN)
 696                         return;
 697                 msleep(10);
 698         }
 699
 700         WARN_ON(1);
 701 }
 702
 703 /**
 704  *      ahci_save_initial_config - Save and fixup initial config values
 705  *      @pdev: target PCI device
 706  *      @hpriv: host private area to store config values
 707  *
 708  *      Some registers containing configuration info might be setup by
 709  *      BIOS and might be cleared on reset.  This function saves the
 710  *      initial values of those registers into @hpriv such that they
 711  *      can be restored after controller reset.
 712  *
 713  *      If inconsistent, config values are fixed up by this function.
 714  *
 715  *      LOCKING:
 716  *      None.
 717  */
 718 static void ahci_save_initial_config(struct pci_dev *pdev,
 719                                      struct ahci_host_priv *hpriv)
 720 {
 721         void __iomem *mmio = pcim_iomap_table(pdev)[AHCI_PCI_BAR];
 722         u32 cap, port_map;
 723         int i;
 724         int mv;
 725
 726         /* make sure AHCI mode is enabled before accessing CAP */
 727         ahci_enable_ahci(mmio);
 728
 729         /* Values prefixed with saved_ are written back to host after
 730          * reset.  Values without are used for driver operation.
 731          */
 732         hpriv->saved_cap = cap = readl(mmio + HOST_CAP);
 733         hpriv->saved_port_map = port_map = readl(mmio + HOST_PORTS_IMPL);
 734
 735         /* some chips have errata preventing 64bit use */
 736         if ((cap & HOST_CAP_64) && (hpriv->flags & AHCI_HFLAG_32BIT_ONLY)) {
 737                 dev_printk(KERN_INFO, &pdev->dev,
 738                            "controller can't do 64bit DMA, forcing 32bit\n");
 739                 cap &= ~HOST_CAP_64;
 740         }
 741
 742         if ((cap & HOST_CAP_NCQ) && (hpriv->flags & AHCI_HFLAG_NO_NCQ)) {
 743                 dev_printk(KERN_INFO, &pdev->dev,
 744                            "controller can't do NCQ, turning off CAP_NCQ\n");
 745                 cap &= ~HOST_CAP_NCQ;
 746         }
 747
 748         if (!(cap & HOST_CAP_NCQ) && (hpriv->flags & AHCI_HFLAG_YES_NCQ)) {
 749                 dev_printk(KERN_INFO, &pdev->dev,
 750                            "controller can do NCQ, turning on CAP_NCQ\n");
 751                 cap |= HOST_CAP_NCQ;
 752         }
 753
 754         if ((cap & HOST_CAP_PMP) && (hpriv->flags & AHCI_HFLAG_NO_PMP)) {
 755                 dev_printk(KERN_INFO, &pdev->dev,
 756                            "controller can't do PMP, turning off CAP_PMP\n");
 757                 cap &= ~HOST_CAP_PMP;
 758         }
 759
 760         if (pdev->vendor == PCI_VENDOR_ID_JMICRON && pdev->device == 0x2361 &&
 761             port_map != 1) {
 762                 dev_printk(KERN_INFO, &pdev->dev,
 763                            "JMB361 has only one port, port_map 0x%x -> 0x%x\n",
 764                            port_map, 1);
 765                 port_map = 1;
 766         }
 767
 768         /*
 769          * Temporary Marvell 6145 hack: PATA port presence
 770          * is asserted through the standard AHCI port
 771          * presence register, as bit 4 (counting from 0)
 772          */
 773         if (hpriv->flags & AHCI_HFLAG_MV_PATA) {
 774                 if (pdev->device == 0x6121)
 775                         mv = 0x3;
 776                 else
 777                         mv = 0xf;
 778                 dev_printk(KERN_ERR, &pdev->dev,
 779                            "MV_AHCI HACK: port_map %x -> %x\n",
 780                            port_map,
 781                            port_map & mv);
 782                 dev_printk(KERN_ERR, &pdev->dev,
 783                           "Disabling your PATA port. Use the boot option 'ahci.marvell_enable=0' to avoid this.\n");
 784
 785                 port_map &= mv;
 786         }
 787
 788         /* cross check port_map and cap.n_ports */
 789         if (port_map) {
 790                 int map_ports = 0;
 791
 792                 for (i = 0; i < AHCI_MAX_PORTS; i++)
 793                         if (port_map & (1 << i))
 794                                 map_ports++;
 795
 796                 /* If PI has more ports than n_ports, whine, clear
 797                  * port_map and let it be generated from n_ports.
 798                  */
 799                 if (map_ports > ahci_nr_ports(cap)) {
 800                         dev_printk(KERN_WARNING, &pdev->dev,
 801                                    "implemented port map (0x%x) contains more "
 802                                    "ports than nr_ports (%u), using nr_ports\n",
 803                                    port_map, ahci_nr_ports(cap));
 804                         port_map = 0;
 805                 }
 806         }
 807
 808         /* fabricate port_map from cap.nr_ports */
 809         if (!port_map) {
 810                 port_map = (1 << ahci_nr_ports(cap)) - 1;
 811                 dev_printk(KERN_WARNING, &pdev->dev,
 812                            "forcing PORTS_IMPL to 0x%x\n", port_map);
 813
 814                 /* write the fixed up value to the PI register */
 815                 hpriv->saved_port_map = port_map;
 816         }
 817
 818         /* record values to use during operation */
 819         hpriv->cap = cap;
 820         hpriv->port_map = port_map;
 821 }
 822
 823 /**
 824  *      ahci_restore_initial_config - Restore initial config
 825  *      @host: target ATA host
 826  *
 827  *      Restore initial config stored by ahci_save_initial_config().
 828  *
 829  *      LOCKING:
 830  *      None.
 831  */
 832 static void ahci_restore_initial_config(struct ata_host *host)
 833 {
 834         struct ahci_host_priv *hpriv = host->private_data;
 835         void __iomem *mmio = host->iomap[AHCI_PCI_BAR];
 836
 837         writel(hpriv->saved_cap, mmio + HOST_CAP);
 838         writel(hpriv->saved_port_map, mmio + HOST_PORTS_IMPL);
 839         (void) readl(mmio + HOST_PORTS_IMPL);   /* flush */
 840 }
 841
 842 static unsigned ahci_scr_offset(struct ata_port *ap, unsigned int sc_reg)
 843 {
 844         static const int offset[] = {
 845                 [SCR_STATUS]            = PORT_SCR_STAT,
 846                 [SCR_CONTROL]           = PORT_SCR_CTL,
 847                 [SCR_ERROR]             = PORT_SCR_ERR,
 848                 [SCR_ACTIVE]            = PORT_SCR_ACT,
 849                 [SCR_NOTIFICATION]      = PORT_SCR_NTF,
 850         };
 851         struct ahci_host_priv *hpriv = ap->host->private_data;
 852
 853         if (sc_reg < ARRAY_SIZE(offset) &&
 854             (sc_reg != SCR_NOTIFICATION || (hpriv->cap & HOST_CAP_SNTF)))
 855                 return offset[sc_reg];
 856         return 0;
 857 }
 858
 859 static int ahci_scr_read(struct ata_link *link, unsigned int sc_reg, u32 *val)
 860 {
 861         void __iomem *port_mmio = ahci_port_base(link->ap);
 862         int offset = ahci_scr_offset(link->ap, sc_reg);
 863
 864         if (offset) {
 865                 *val = readl(port_mmio + offset);
 866                 return 0;
 867         }
 868         return -EINVAL;
 869 }
 870
 871 static int ahci_scr_write(struct ata_link *link, unsigned int sc_reg, u32 val)
 872 {
 873         void __iomem *port_mmio = ahci_port_base(link->ap);
 874         int offset = ahci_scr_offset(link->ap, sc_reg);
 875
 876         if (offset) {
 877                 writel(val, port_mmio + offset);
 878                 return 0;
 879         }
 880         return -EINVAL;
 881 }
 882
 883 static void ahci_start_engine(struct ata_port *ap)
 884 {
 885         void __iomem *port_mmio = ahci_port_base(ap);
 886         u32 tmp;
 887
 888         /* start DMA */
 889         tmp = readl(port_mmio + PORT_CMD);
 890         tmp |= PORT_CMD_START;
 891         writel(tmp, port_mmio + PORT_CMD);
 892         readl(port_mmio + PORT_CMD); /* flush */
 893 }
 894
 895 static int ahci_stop_engine(struct ata_port *ap)
 896 {
 897         void __iomem *port_mmio = ahci_port_base(ap);
 898         u32 tmp;
 899
 900         tmp = readl(port_mmio + PORT_CMD);
 901
 902         /* check if the HBA is idle */
 903         if ((tmp & (PORT_CMD_START | PORT_CMD_LIST_ON)) == 0)
 904                 return 0;
 905
 906         /* setting HBA to idle */
 907         tmp &= ~PORT_CMD_START;
 908         writel(tmp, port_mmio + PORT_CMD);
 909
 910         /* wait for engine to stop. This could be as long as 500 msec */
 911         tmp = ata_wait_register(port_mmio + PORT_CMD,
 912                                 PORT_CMD_LIST_ON, PORT_CMD_LIST_ON, 1, 500);
 913         if (tmp & PORT_CMD_LIST_ON)
 914                 return -EIO;
 915
 916         return 0;
 917 }
 918
 919 static void ahci_start_fis_rx(struct ata_port *ap)
 920 {
 921         void __iomem *port_mmio = ahci_port_base(ap);
 922         struct ahci_host_priv *hpriv = ap->host->private_data;
 923         struct ahci_port_priv *pp = ap->private_data;
 924         u32 tmp;
 925
 926         /* set FIS registers */
 927         if (hpriv->cap & HOST_CAP_64)
 928                 writel((pp->cmd_slot_dma >> 16) >> 16,
 929                        port_mmio + PORT_LST_ADDR_HI);
 930         writel(pp->cmd_slot_dma & 0xffffffff, port_mmio + PORT_LST_ADDR);
 931
 932         if (hpriv->cap & HOST_CAP_64)
 933                 writel((pp->rx_fis_dma >> 16) >> 16,
 934                        port_mmio + PORT_FIS_ADDR_HI);
 935         writel(pp->rx_fis_dma & 0xffffffff, port_mmio + PORT_FIS_ADDR);
 936
 937         /* enable FIS reception */
 938         tmp = readl(port_mmio + PORT_CMD);
 939         tmp |= PORT_CMD_FIS_RX;
 940         writel(tmp, port_mmio + PORT_CMD);
 941
 942         /* flush */
 943         readl(port_mmio + PORT_CMD);
 944 }
 945
 946 static int ahci_stop_fis_rx(struct ata_port *ap)
 947 {
 948         void __iomem *port_mmio = ahci_port_base(ap);
 949         u32 tmp;
 950
 951         /* disable FIS reception */
 952         tmp = readl(port_mmio + PORT_CMD);
 953         tmp &= ~PORT_CMD_FIS_RX;
 954         writel(tmp, port_mmio + PORT_CMD);
 955
 956         /* wait for completion, spec says 500ms, give it 1000 */
 957         tmp = ata_wait_register(port_mmio + PORT_CMD, PORT_CMD_FIS_ON,
 958                                 PORT_CMD_FIS_ON, 10, 1000);
 959         if (tmp & PORT_CMD_FIS_ON)
 960                 return -EBUSY;
 961
 962         return 0;
 963 }
 964
 965 static void ahci_power_up(struct ata_port *ap)
 966 {
 967         struct ahci_host_priv *hpriv = ap->host->private_data;
 968         void __iomem *port_mmio = ahci_port_base(ap);
 969         u32 cmd;
 970
 971         cmd = readl(port_mmio + PORT_CMD) & ~PORT_CMD_ICC_MASK;
 972
 973         /* spin up device */
 974         if (hpriv->cap & HOST_CAP_SSS) {
 975                 cmd |= PORT_CMD_SPIN_UP;
 976                 writel(cmd, port_mmio + PORT_CMD);
 977         }
 978
 979         /* wake up link */
 980         writel(cmd | PORT_CMD_ICC_ACTIVE, port_mmio + PORT_CMD);
 981 }
 982
 983 static void ahci_disable_alpm(struct ata_port *ap)
 984 {
 985         struct ahci_host_priv *hpriv = ap->host->private_data;
 986         void __iomem *port_mmio = ahci_port_base(ap);
 987         u32 cmd;
 988         struct ahci_port_priv *pp = ap->private_data;
 989
 990         /* IPM bits should be disabled by libata-core */
 991         /* get the existing command bits */
 992         cmd = readl(port_mmio + PORT_CMD);
 993
 994         /* disable ALPM and ASP */
 995         cmd &= ~PORT_CMD_ASP;
 996         cmd &= ~PORT_CMD_ALPE;
 997
 998         /* force the interface back to active */
 999         cmd |= PORT_CMD_ICC_ACTIVE;
1000
1001         /* write out new cmd value */
1002         writel(cmd, port_mmio + PORT_CMD);
1003         cmd = readl(port_mmio + PORT_CMD);
1004
1005         /* wait 10ms to be sure we've come out of any low power state */
1006         msleep(10);
1007
1008         /* clear out any PhyRdy stuff from interrupt status */
1009         writel(PORT_IRQ_PHYRDY, port_mmio + PORT_IRQ_STAT);
1010
1011         /* go ahead and clean out PhyRdy Change from Serror too */
1012         ahci_scr_write(&ap->link, SCR_ERROR, ((1 << 16) | (1 << 18)));
1013
1014         /*
1015          * Clear flag to indicate that we should ignore all PhyRdy
1016          * state changes
1017          */
1018         hpriv->flags &= ~AHCI_HFLAG_NO_HOTPLUG;
1019
1020         /*
1021          * Enable interrupts on Phy Ready.
1022          */
1023         pp->intr_mask |= PORT_IRQ_PHYRDY;
1024         writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK);
1025
1026         /*
1027          * don't change the link pm policy - we can be called
1028          * just to turn of link pm temporarily
1029          */
1030 }
1031
1032 static int ahci_enable_alpm(struct ata_port *ap,
1033         enum link_pm policy)
1034 {
1035         struct ahci_host_priv *hpriv = ap->host->private_data;
1036         void __iomem *port_mmio = ahci_port_base(ap);
1037         u32 cmd;
1038         struct ahci_port_priv *pp = ap->private_data;
1039         u32 asp;
1040
1041         /* Make sure the host is capable of link power management */
1042         if (!(hpriv->cap & HOST_CAP_ALPM))
1043                 return -EINVAL;
1044
1045         switch (policy) {
1046         case MAX_PERFORMANCE:
1047         case NOT_AVAILABLE:
1048                 /*
1049                  * if we came here with NOT_AVAILABLE,
1050                  * it just means this is the first time we
1051                  * have tried to enable - default to max performance,
1052                  * and let the user go to lower power modes on request.
1053                  */
1054                 ahci_disable_alpm(ap);
1055                 return 0;
1056         case MIN_POWER:
1057                 /* configure HBA to enter SLUMBER */
1058                 asp = PORT_CMD_ASP;
1059                 break;
1060         case MEDIUM_POWER:
1061                 /* configure HBA to enter PARTIAL */
1062                 asp = 0;
1063                 break;
1064         default:
1065                 return -EINVAL;
1066         }
1067
1068         /*
1069          * Disable interrupts on Phy Ready. This keeps us from
1070          * getting woken up due to spurious phy ready interrupts
1071          * TBD - Hot plug should be done via polling now, is
1072          * that even supported?
1073          */
1074         pp->intr_mask &= ~PORT_IRQ_PHYRDY;
1075         writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK);
1076
1077         /*
1078          * Set a flag to indicate that we should ignore all PhyRdy
1079          * state changes since these can happen now whenever we
1080          * change link state
1081          */
1082         hpriv->flags |= AHCI_HFLAG_NO_HOTPLUG;
1083
1084         /* get the existing command bits */
1085         cmd = readl(port_mmio + PORT_CMD);
1086
1087         /*
1088          * Set ASP based on Policy
1089          */
1090         cmd |= asp;
1091
1092         /*
1093          * Setting this bit will instruct the HBA to aggressively
1094          * enter a lower power link state when it's appropriate and
1095          * based on the value set above for ASP
1096          */
1097         cmd |= PORT_CMD_ALPE;
1098
1099         /* write out new cmd value */
1100         writel(cmd, port_mmio + PORT_CMD);
1101         cmd = readl(port_mmio + PORT_CMD);
1102
1103         /* IPM bits should be set by libata-core */
1104         return 0;
1105 }
1106
1107 #ifdef CONFIG_PM
1108 static void ahci_power_down(struct ata_port *ap)
1109 {
1110         struct ahci_host_priv *hpriv = ap->host->private_data;
1111         void __iomem *port_mmio = ahci_port_base(ap);
1112         u32 cmd, scontrol;
1113
1114         if (!(hpriv->cap & HOST_CAP_SSS))
1115                 return;
1116
1117         /* put device into listen mode, first set PxSCTL.DET to 0 */
1118         scontrol = readl(port_mmio + PORT_SCR_CTL);
1119         scontrol &= ~0xf;
1120         writel(scontrol, port_mmio + PORT_SCR_CTL);
1121
1122         /* then set PxCMD.SUD to 0 */
1123         cmd = readl(port_mmio + PORT_CMD) & ~PORT_CMD_ICC_MASK;
1124         cmd &= ~PORT_CMD_SPIN_UP;
1125         writel(cmd, port_mmio + PORT_CMD);
1126 }
1127 #endif
1128
1129 static void ahci_start_port(struct ata_port *ap)
1130 {
1131         struct ahci_port_priv *pp = ap->private_data;
1132         struct ata_link *link;
1133         struct ahci_em_priv *emp;
1134         ssize_t rc;
1135         int i;
1136
1137         /* enable FIS reception */
1138         ahci_start_fis_rx(ap);
1139
1140         /* enable DMA */
1141         ahci_start_engine(ap);
1142
1143         /* turn on LEDs */
1144         if (ap->flags & ATA_FLAG_EM) {
1145                 ata_for_each_link(link, ap, EDGE) {
1146                         emp = &pp->em_priv[link->pmp];
1147
1148                         /* EM Transmit bit maybe busy during init */
1149                         for (i = 0; i < EM_MAX_RETRY; i++) {
1150                                 rc = ahci_transmit_led_message(ap,
1151                                                                emp->led_state,
1152                                                                4);
1153                                 if (rc == -EBUSY)
1154                                         msleep(1);
1155                                 else
1156                                         break;
1157                         }
1158                 }
1159         }
1160
1161         if (ap->flags & ATA_FLAG_SW_ACTIVITY)
1162                 ata_for_each_link(link, ap, EDGE)
1163                         ahci_init_sw_activity(link);
1164
1165 }
1166
1167 static int ahci_deinit_port(struct ata_port *ap, const char **emsg)
1168 {
1169         int rc;
1170
1171         /* disable DMA */
1172         rc = ahci_stop_engine(ap);
1173         if (rc) {
1174                 *emsg = "failed to stop engine";
1175                 return rc;
1176         }
1177
1178         /* disable FIS reception */
1179         rc = ahci_stop_fis_rx(ap);
1180         if (rc) {
1181                 *emsg = "failed stop FIS RX";
1182                 return rc;
1183         }
1184
1185         return 0;
1186 }
1187
1188 static int ahci_reset_controller(struct ata_host *host)
1189 {
1190         struct pci_dev *pdev = to_pci_dev(host->dev);
1191         struct ahci_host_priv *hpriv = host->private_data;
1192         void __iomem *mmio = host->iomap[AHCI_PCI_BAR];
1193         u32 tmp;
1194
1195         /* we must be in AHCI mode, before using anything
1196          * AHCI-specific, such as HOST_RESET.
1197          */
1198         ahci_enable_ahci(mmio);
1199
1200         /* global controller reset */
1201         if (!ahci_skip_host_reset) {
1202                 tmp = readl(mmio + HOST_CTL);
1203                 if ((tmp & HOST_RESET) == 0) {
1204                         writel(tmp | HOST_RESET, mmio + HOST_CTL);
1205                         readl(mmio + HOST_CTL); /* flush */
1206                 }
1207
1208                 /*
1209                  * to perform host reset, OS should set HOST_RESET
1210                  * and poll until this bit is read to be "0".
1211                  * reset must complete within 1 second, or
1212                  * the hardware should be considered fried.
1213                  */
1214                 tmp = ata_wait_register(mmio + HOST_CTL, HOST_RESET,
1215                                         HOST_RESET, 10, 1000);
1216
1217                 if (tmp & HOST_RESET) {
1218                         dev_printk(KERN_ERR, host->dev,
1219                                    "controller reset failed (0x%x)\n", tmp);
1220                         return -EIO;
1221                 }
1222
1223                 /* turn on AHCI mode */
1224                 ahci_enable_ahci(mmio);
1225
1226                 /* Some registers might be cleared on reset.  Restore
1227                  * initial values.
1228                  */
1229                 ahci_restore_initial_config(host);
1230         } else
1231                 dev_printk(KERN_INFO, host->dev,
1232                            "skipping global host reset\n");
1233
1234         if (pdev->vendor == PCI_VENDOR_ID_INTEL) {
1235                 u16 tmp16;
1236
1237                 /* configure PCS */
1238                 pci_read_config_word(pdev, 0x92, &tmp16);
1239                 if ((tmp16 & hpriv->port_map) != hpriv->port_map) {
1240                         tmp16 |= hpriv->port_map;
1241                         pci_write_config_word(pdev, 0x92, tmp16);
1242                 }
1243         }
1244
1245         return 0;
1246 }
1247
1248 static void ahci_sw_activity(struct ata_link *link)
1249 {
1250         struct ata_port *ap = link->ap;
1251         struct ahci_port_priv *pp = ap->private_data;
1252         struct ahci_em_priv *emp = &pp->em_priv[link->pmp];
1253
1254         if (!(link->flags & ATA_LFLAG_SW_ACTIVITY))
1255                 return;
1256
1257         emp->activity++;
1258         if (!timer_pending(&emp->timer))
1259                 mod_timer(&emp->timer, jiffies + msecs_to_jiffies(10));
1260 }
1261
1262 static void ahci_sw_activity_blink(unsigned long arg)
1263 {
1264         struct ata_link *link = (struct ata_link *)arg;
1265         struct ata_port *ap = link->ap;
1266         struct ahci_port_priv *pp = ap->private_data;
1267         struct ahci_em_priv *emp = &pp->em_priv[link->pmp];
1268         unsigned long led_message = emp->led_state;
1269         u32 activity_led_state;
1270         unsigned long flags;
1271
1272         led_message &= EM_MSG_LED_VALUE;
1273         led_message |= ap->port_no | (link->pmp << 8);
1274
1275         /* check to see if we've had activity.  If so,
1276          * toggle state of LED and reset timer.  If not,
1277          * turn LED to desired idle state.
1278          */
1279         spin_lock_irqsave(ap->lock, flags);
1280         if (emp->saved_activity != emp->activity) {
1281                 emp->saved_activity = emp->activity;
1282                 /* get the current LED state */
1283                 activity_led_state = led_message & EM_MSG_LED_VALUE_ON;
1284
1285                 if (activity_led_state)
1286                         activity_led_state = 0;
1287                 else
1288                         activity_led_state = 1;
1289
1290                 /* clear old state */
1291                 led_message &= ~EM_MSG_LED_VALUE_ACTIVITY;
1292
1293                 /* toggle state */
1294                 led_message |= (activity_led_state << 16);
1295                 mod_timer(&emp->timer, jiffies + msecs_to_jiffies(100));
1296         } else {
1297                 /* switch to idle */
1298                 led_message &= ~EM_MSG_LED_VALUE_ACTIVITY;
1299                 if (emp->blink_policy == BLINK_OFF)
1300                         led_message |= (1 << 16);
1301         }
1302         spin_unlock_irqrestore(ap->lock, flags);
1303         ahci_transmit_led_message(ap, led_message, 4);
1304 }
1305
1306 static void ahci_init_sw_activity(struct ata_link *link)
1307 {
1308         struct ata_port *ap = link->ap;
1309         struct ahci_port_priv *pp = ap->private_data;
1310         struct ahci_em_priv *emp = &pp->em_priv[link->pmp];
1311
1312         /* init activity stats, setup timer */
1313         emp->saved_activity = emp->activity = 0;
1314         setup_timer(&emp->timer, ahci_sw_activity_blink, (unsigned long)link);
1315
1316         /* check our blink policy and set flag for link if it's enabled */
1317         if (emp->blink_policy)
1318                 link->flags |= ATA_LFLAG_SW_ACTIVITY;
1319 }
1320
1321 static int ahci_reset_em(struct ata_host *host)
1322 {
1323         void __iomem *mmio = host->iomap[AHCI_PCI_BAR];
1324         u32 em_ctl;
1325
1326         em_ctl = readl(mmio + HOST_EM_CTL);
1327         if ((em_ctl & EM_CTL_TM) || (em_ctl & EM_CTL_RST))
1328                 return -EINVAL;
1329
1330         writel(em_ctl | EM_CTL_RST, mmio + HOST_EM_CTL);
1331         return 0;
1332 }
1333
1334 static ssize_t ahci_transmit_led_message(struct ata_port *ap, u32 state,
1335                                         ssize_t size)
1336 {
1337         struct ahci_host_priv *hpriv = ap->host->private_data;
1338         struct ahci_port_priv *pp = ap->private_data;
1339         void __iomem *mmio = ap->host->iomap[AHCI_PCI_BAR];
1340         u32 em_ctl;
1341         u32 message[] = {0, 0};
1342         unsigned long flags;
1343         int pmp;
1344         struct ahci_em_priv *emp;
1345
1346         /* get the slot number from the message */
1347         pmp = (state & EM_MSG_LED_PMP_SLOT) >> 8;
1348         if (pmp < EM_MAX_SLOTS)
1349                 emp = &pp->em_priv[pmp];
1350         else
1351                 return -EINVAL;
1352
1353         spin_lock_irqsave(ap->lock, flags);
1354
1355         /*
1356          * if we are still busy transmitting a previous message,
1357          * do not allow
1358          */
1359         em_ctl = readl(mmio + HOST_EM_CTL);
1360         if (em_ctl & EM_CTL_TM) {
1361                 spin_unlock_irqrestore(ap->lock, flags);
1362                 return -EBUSY;
1363         }
1364
1365         /*
1366          * create message header - this is all zero except for
1367          * the message size, which is 4 bytes.
1368          */
1369         message[0] |= (4 << 8);
1370
1371         /* ignore 0:4 of byte zero, fill in port info yourself */
1372         message[1] = ((state & ~EM_MSG_LED_HBA_PORT) | ap->port_no);
1373
1374         /* write message to EM_LOC */
1375         writel(message[0], mmio + hpriv->em_loc);
1376         writel(message[1], mmio + hpriv->em_loc+4);
1377
1378         /* save off new led state for port/slot */
1379         emp->led_state = state;
1380
1381         /*
1382          * tell hardware to transmit the message
1383          */
1384         writel(em_ctl | EM_CTL_TM, mmio + HOST_EM_CTL);
1385
1386         spin_unlock_irqrestore(ap->lock, flags);
1387         return size;
1388 }
1389
1390 static ssize_t ahci_led_show(struct ata_port *ap, char *buf)
1391 {
1392         struct ahci_port_priv *pp = ap->private_data;
1393         struct ata_link *link;
1394         struct ahci_em_priv *emp;
1395         int rc = 0;
1396
1397         ata_for_each_link(link, ap, EDGE) {
1398                 emp = &pp->em_priv[link->pmp];
1399                 rc += sprintf(buf, "%lx\n", emp->led_state);
1400         }
1401         return rc;
1402 }
1403
1404 static ssize_t ahci_led_store(struct ata_port *ap, const char *buf,
1405                                 size_t size)
1406 {
1407         int state;
1408         int pmp;
1409         struct ahci_port_priv *pp = ap->private_data;
1410         struct ahci_em_priv *emp;
1411
1412         state = simple_strtoul(buf, NULL, 0);
1413
1414         /* get the slot number from the message */
1415         pmp = (state & EM_MSG_LED_PMP_SLOT) >> 8;
1416         if (pmp < EM_MAX_SLOTS)
1417                 emp = &pp->em_priv[pmp];
1418         else
1419                 return -EINVAL;
1420
1421         /* mask off the activity bits if we are in sw_activity
1422          * mode, user should turn off sw_activity before setting
1423          * activity led through em_message
1424          */
1425         if (emp->blink_policy)
1426                 state &= ~EM_MSG_LED_VALUE_ACTIVITY;
1427
1428         return ahci_transmit_led_message(ap, state, size);
1429 }
1430
1431 static ssize_t ahci_activity_store(struct ata_device *dev, enum sw_activity val)
1432 {
1433         struct ata_link *link = dev->link;
1434         struct ata_port *ap = link->ap;
1435         struct ahci_port_priv *pp = ap->private_data;
1436         struct ahci_em_priv *emp = &pp->em_priv[link->pmp];
1437         u32 port_led_state = emp->led_state;
1438
1439         /* save the desired Activity LED behavior */
1440         if (val == OFF) {
1441                 /* clear LFLAG */
1442                 link->flags &= ~(ATA_LFLAG_SW_ACTIVITY);
1443
1444                 /* set the LED to OFF */
1445                 port_led_state &= EM_MSG_LED_VALUE_OFF;
1446                 port_led_state |= (ap->port_no | (link->pmp << 8));
1447                 ahci_transmit_led_message(ap, port_led_state, 4);
1448         } else {
1449                 link->flags |= ATA_LFLAG_SW_ACTIVITY;
1450                 if (val == BLINK_OFF) {
1451                         /* set LED to ON for idle */
1452                         port_led_state &= EM_MSG_LED_VALUE_OFF;
1453                         port_led_state |= (ap->port_no | (link->pmp << 8));
1454                         port_led_state |= EM_MSG_LED_VALUE_ON; /* check this */
1455                         ahci_transmit_led_message(ap, port_led_state, 4);
1456                 }
1457         }
1458         emp->blink_policy = val;
1459         return 0;
1460 }
1461
1462 static ssize_t ahci_activity_show(struct ata_device *dev, char *buf)
1463 {
1464         struct ata_link *link = dev->link;
1465         struct ata_port *ap = link->ap;
1466         struct ahci_port_priv *pp = ap->private_data;
1467         struct ahci_em_priv *emp = &pp->em_priv[link->pmp];
1468
1469         /* display the saved value of activity behavior for this
1470          * disk.
1471          */
1472         return sprintf(buf, "%d\n", emp->blink_policy);
1473 }
1474
1475 static void ahci_port_init(struct pci_dev *pdev, struct ata_port *ap,
1476                            int port_no, void __iomem *mmio,
1477                            void __iomem *port_mmio)
1478 {
1479         const char *emsg = NULL;
1480         int rc;
1481         u32 tmp;
1482
1483         /* make sure port is not active */
1484         rc = ahci_deinit_port(ap, &emsg);
1485         if (rc)
1486                 dev_printk(KERN_WARNING, &pdev->dev,
1487                            "%s (%d)\n", emsg, rc);
1488
1489         /* clear SError */
1490         tmp = readl(port_mmio + PORT_SCR_ERR);
1491         VPRINTK("PORT_SCR_ERR 0x%x\n", tmp);
1492         writel(tmp, port_mmio + PORT_SCR_ERR);
1493
1494         /* clear port IRQ */
1495         tmp = readl(port_mmio + PORT_IRQ_STAT);
1496         VPRINTK("PORT_IRQ_STAT 0x%x\n", tmp);
1497         if (tmp)
1498                 writel(tmp, port_mmio + PORT_IRQ_STAT);
1499
1500         writel(1 << port_no, mmio + HOST_IRQ_STAT);
1501 }
1502
1503 static void ahci_init_controller(struct ata_host *host)
1504 {
1505         struct ahci_host_priv *hpriv = host->private_data;
1506         struct pci_dev *pdev = to_pci_dev(host->dev);
1507         void __iomem *mmio = host->iomap[AHCI_PCI_BAR];
1508         int i;
1509         void __iomem *port_mmio;
1510         u32 tmp;
1511         int mv;
1512
1513         if (hpriv->flags & AHCI_HFLAG_MV_PATA) {
1514                 if (pdev->device == 0x6121)
1515                         mv = 2;
1516                 else
1517                         mv = 4;
1518                 port_mmio = __ahci_port_base(host, mv);
1519
1520                 writel(0, port_mmio + PORT_IRQ_MASK);
1521
1522                 /* clear port IRQ */
1523                 tmp = readl(port_mmio + PORT_IRQ_STAT);
1524                 VPRINTK("PORT_IRQ_STAT 0x%x\n", tmp);
1525                 if (tmp)
1526                         writel(tmp, port_mmio + PORT_IRQ_STAT);
1527         }
1528
1529         for (i = 0; i < host->n_ports; i++) {
1530                 struct ata_port *ap = host->ports[i];
1531
1532                 port_mmio = ahci_port_base(ap);
1533                 if (ata_port_is_dummy(ap))
1534                         continue;
1535
1536                 ahci_port_init(pdev, ap, i, mmio, port_mmio);
1537         }
1538
1539         tmp = readl(mmio + HOST_CTL);
1540         VPRINTK("HOST_CTL 0x%x\n", tmp);
1541         writel(tmp | HOST_IRQ_EN, mmio + HOST_CTL);
1542         tmp = readl(mmio + HOST_CTL);
1543         VPRINTK("HOST_CTL 0x%x\n", tmp);
1544 }
1545
1546 static void ahci_dev_config(struct ata_device *dev)
1547 {
1548         struct ahci_host_priv *hpriv = dev->link->ap->host->private_data;
1549
1550         if (hpriv->flags & AHCI_HFLAG_SECT255) {
1551                 dev->max_sectors = 255;
1552                 ata_dev_printk(dev, KERN_INFO,
1553                                "SB600 AHCI: limiting to 255 sectors per cmd\n");
1554         }
1555 }
1556
1557 static unsigned int ahci_dev_classify(struct ata_port *ap)
1558 {
1559         void __iomem *port_mmio = ahci_port_base(ap);
1560         struct ata_taskfile tf;
1561         u32 tmp;
1562
1563         tmp = readl(port_mmio + PORT_SIG);
1564         tf.lbah         = (tmp >> 24)   & 0xff;
1565         tf.lbam         = (tmp >> 16)   & 0xff;
1566         tf.lbal         = (tmp >> 8)    & 0xff;
1567         tf.nsect        = (tmp)         & 0xff;
1568
1569         return ata_dev_classify(&tf);
1570 }
1571
1572 static void ahci_fill_cmd_slot(struct ahci_port_priv *pp, unsigned int tag,
1573                                u32 opts)
1574 {
1575         dma_addr_t cmd_tbl_dma;
1576
1577         cmd_tbl_dma = pp->cmd_tbl_dma + tag * AHCI_CMD_TBL_SZ;
1578
1579         pp->cmd_slot[tag].opts = cpu_to_le32(opts);
1580         pp->cmd_slot[tag].status = 0;
1581         pp->cmd_slot[tag].tbl_addr = cpu_to_le32(cmd_tbl_dma & 0xffffffff);
1582         pp->cmd_slot[tag].tbl_addr_hi = cpu_to_le32((cmd_tbl_dma >> 16) >> 16);
1583 }
1584
1585 static int ahci_kick_engine(struct ata_port *ap, int force_restart)
1586 {
1587         void __iomem *port_mmio = ahci_port_base(ap);
1588         struct ahci_host_priv *hpriv = ap->host->private_data;
1589         u8 status = readl(port_mmio + PORT_TFDATA) & 0xFF;
1590         u32 tmp;
1591         int busy, rc;
1592
1593         /* do we need to kick the port? */
1594         busy = status & (ATA_BUSY | ATA_DRQ);
1595         if (!busy && !force_restart)
1596                 return 0;
1597
1598         /* stop engine */
1599         rc = ahci_stop_engine(ap);
1600         if (rc)
1601                 goto out_restart;
1602
1603         /* need to do CLO? */
1604         if (!busy) {
1605                 rc = 0;
1606                 goto out_restart;
1607         }
1608
1609         if (!(hpriv->cap & HOST_CAP_CLO)) {
1610                 rc = -EOPNOTSUPP;
1611                 goto out_restart;
1612         }
1613
1614         /* perform CLO */
1615         tmp = readl(port_mmio + PORT_CMD);
1616         tmp |= PORT_CMD_CLO;
1617         writel(tmp, port_mmio + PORT_CMD);
1618
1619         rc = 0;
1620         tmp = ata_wait_register(port_mmio + PORT_CMD,
1621                                 PORT_CMD_CLO, PORT_CMD_CLO, 1, 500);
1622         if (tmp & PORT_CMD_CLO)
1623                 rc = -EIO;
1624
1625         /* restart engine */
1626  out_restart:
1627         ahci_start_engine(ap);
1628         return rc;
1629 }
1630
1631 static int ahci_exec_polled_cmd(struct ata_port *ap, int pmp,
1632                                 struct ata_taskfile *tf, int is_cmd, u16 flags,
1633                                 unsigned long timeout_msec)
1634 {
1635         const u32 cmd_fis_len = 5; /* five dwords */
1636         struct ahci_port_priv *pp = ap->private_data;
1637         void __iomem *port_mmio = ahci_port_base(ap);
1638         u8 *fis = pp->cmd_tbl;
1639         u32 tmp;
1640
1641         /* prep the command */
1642         ata_tf_to_fis(tf, pmp, is_cmd, fis);
1643         ahci_fill_cmd_slot(pp, 0, cmd_fis_len | flags | (pmp << 12));
1644
1645         /* issue & wait */
1646         writel(1, port_mmio + PORT_CMD_ISSUE);
1647
1648         if (timeout_msec) {
1649                 tmp = ata_wait_register(port_mmio + PORT_CMD_ISSUE, 0x1, 0x1,
1650                                         1, timeout_msec);
1651                 if (tmp & 0x1) {
1652                         ahci_kick_engine(ap, 1);
1653                         return -EBUSY;
1654                 }
1655         } else
1656                 readl(port_mmio + PORT_CMD_ISSUE);      /* flush */
1657
1658         return 0;
1659 }
1660
1661 static int ahci_do_softreset(struct ata_link *link, unsigned int *class,
1662                              int pmp, unsigned long deadline,
1663                              int (*check_ready)(struct ata_link *link))
1664 {
1665         struct ata_port *ap = link->ap;
1666         const char *reason = NULL;
1667         unsigned long now, msecs;
1668         struct ata_taskfile tf;
1669         int rc;
1670
1671         DPRINTK("ENTER\n");
1672
1673         /* prepare for SRST (AHCI-1.1 10.4.1) */
1674         rc = ahci_kick_engine(ap, 1);
1675         if (rc && rc != -EOPNOTSUPP)
1676                 ata_link_printk(link, KERN_WARNING,
1677                                 "failed to reset engine (errno=%d)\n", rc);
1678
1679         ata_tf_init(link->device, &tf);
1680
1681         /* issue the first D2H Register FIS */
1682         msecs = 0;
1683         now = jiffies;
1684         if (time_after(now, deadline))
1685                 msecs = jiffies_to_msecs(deadline - now);
1686
1687         tf.ctl |= ATA_SRST;
1688         if (ahci_exec_polled_cmd(ap, pmp, &tf, 0,
1689                                  AHCI_CMD_RESET | AHCI_CMD_CLR_BUSY, msecs)) {
1690                 rc = -EIO;
1691                 reason = "1st FIS failed";
1692                 goto fail;
1693         }
1694
1695         /* spec says at least 5us, but be generous and sleep for 1ms */
1696         msleep(1);
1697
1698         /* issue the second D2H Register FIS */
1699         tf.ctl &= ~ATA_SRST;
1700         ahci_exec_polled_cmd(ap, pmp, &tf, 0, 0, 0);
1701
1702         /* wait for link to become ready */
1703         rc = ata_wait_after_reset(link, deadline, check_ready);
1704         /* link occupied, -ENODEV too is an error */
1705         if (rc) {
1706                 reason = "device not ready";
1707                 goto fail;
1708         }
1709         *class = ahci_dev_classify(ap);
1710
1711         DPRINTK("EXIT, class=%u\n", *class);
1712         return 0;
1713
1714  fail:
1715         ata_link_printk(link, KERN_ERR, "softreset failed (%s)\n", reason);
1716         return rc;
1717 }
1718
1719 static int ahci_check_ready(struct ata_link *link)
1720 {
1721         void __iomem *port_mmio = ahci_port_base(link->ap);
1722         u8 status = readl(port_mmio + PORT_TFDATA) & 0xFF;
1723
1724         return ata_check_ready(status);
1725 }
1726
1727 static int ahci_softreset(struct ata_link *link, unsigned int *class,
1728                           unsigned long deadline)
1729 {
1730         int pmp = sata_srst_pmp(link);
1731
1732         DPRINTK("ENTER\n");
1733
1734         return ahci_do_softreset(link, class, pmp, deadline, ahci_check_ready);
1735 }
1736
1737 static int ahci_sb600_check_ready(struct ata_link *link)
1738 {
1739         void __iomem *port_mmio = ahci_port_base(link->ap);
1740         u8 status = readl(port_mmio + PORT_TFDATA) & 0xFF;
1741         u32 irq_status = readl(port_mmio + PORT_IRQ_STAT);
1742
1743         /*
1744          * There is no need to check TFDATA if BAD PMP is found due to HW bug,
1745          * which can save timeout delay.
1746          */
1747         if (irq_status & PORT_IRQ_BAD_PMP)
1748                 return -EIO;
1749
1750         return ata_check_ready(status);
1751 }
1752
1753 static int ahci_sb600_softreset(struct ata_link *link, unsigned int *class,
1754                                 unsigned long deadline)
1755 {
1756         struct ata_port *ap = link->ap;
1757         void __iomem *port_mmio = ahci_port_base(ap);
1758         int pmp = sata_srst_pmp(link);
1759         int rc;
1760         u32 irq_sts;
1761
1762         DPRINTK("ENTER\n");
1763
1764         rc = ahci_do_softreset(link, class, pmp, deadline,
1765                                ahci_sb600_check_ready);
1766
1767         /*
1768          * Soft reset fails on some ATI chips with IPMS set when PMP
1769          * is enabled but SATA HDD/ODD is connected to SATA port,
1770          * do soft reset again to port 0.
1771          */
1772         if (rc == -EIO) {
1773                 irq_sts = readl(port_mmio + PORT_IRQ_STAT);
1774                 if (irq_sts & PORT_IRQ_BAD_PMP) {
1775                         ata_link_printk(link, KERN_WARNING,
1776                                         "failed due to HW bug, retry pmp=0\n");
1777                         rc = ahci_do_softreset(link, class, 0, deadline,
1778                                                ahci_check_ready);
1779                 }
1780         }
1781
1782         return rc;
1783 }
1784
1785 static int ahci_hardreset(struct ata_link *link, unsigned int *class,
1786                           unsigned long deadline)
1787 {
1788         const unsigned long *timing = sata_ehc_deb_timing(&link->eh_context);
1789         struct ata_port *ap = link->ap;
1790         struct ahci_port_priv *pp = ap->private_data;
1791         u8 *d2h_fis = pp->rx_fis + RX_FIS_D2H_REG;
1792         struct ata_taskfile tf;
1793         bool online;
1794         int rc;
1795
1796         DPRINTK("ENTER\n");
1797
1798         ahci_stop_engine(ap);
1799
1800         /* clear D2H reception area to properly wait for D2H FIS */
1801         ata_tf_init(link->device, &tf);
1802         tf.command = 0x80;
1803         ata_tf_to_fis(&tf, 0, 0, d2h_fis);
1804
1805         rc = sata_link_hardreset(link, timing, deadline, &online,
1806                                  ahci_check_ready);
1807
1808         ahci_start_engine(ap);
1809
1810         if (online)
1811                 *class = ahci_dev_classify(ap);
1812
1813         DPRINTK("EXIT, rc=%d, class=%u\n", rc, *class);
1814         return rc;
1815 }
1816
1817 static int ahci_vt8251_hardreset(struct ata_link *link, unsigned int *class,
1818                                  unsigned long deadline)
1819 {
1820         struct ata_port *ap = link->ap;
1821         bool online;
1822         int rc;
1823
1824         DPRINTK("ENTER\n");
1825
1826         ahci_stop_engine(ap);
1827
1828         rc = sata_link_hardreset(link, sata_ehc_deb_timing(&link->eh_context),
1829                                  deadline, &online, NULL);
1830
1831         ahci_start_engine(ap);
1832
1833         DPRINTK("EXIT, rc=%d, class=%u\n", rc, *class);
1834
1835         /* vt8251 doesn't clear BSY on signature FIS reception,
1836          * request follow-up softreset.
1837          */
1838         return online ? -EAGAIN : rc;
1839 }
1840
1841 static int ahci_p5wdh_hardreset(struct ata_link *link, unsigned int *class,
1842                                 unsigned long deadline)
1843 {
1844         struct ata_port *ap = link->ap;
1845         struct ahci_port_priv *pp = ap->private_data;
1846         u8 *d2h_fis = pp->rx_fis + RX_FIS_D2H_REG;
1847         struct ata_taskfile tf;
1848         bool online;
1849         int rc;
1850
1851         ahci_stop_engine(ap);
1852
1853         /* clear D2H reception area to properly wait for D2H FIS */
1854         ata_tf_init(link->device, &tf);
1855         tf.command = 0x80;
1856         ata_tf_to_fis(&tf, 0, 0, d2h_fis);
1857
1858         rc = sata_link_hardreset(link, sata_ehc_deb_timing(&link->eh_context),
1859                                  deadline, &online, NULL);
1860
1861         ahci_start_engine(ap);
1862
1863         /* The pseudo configuration device on SIMG4726 attached to
1864          * ASUS P5W-DH Deluxe doesn't send signature FIS after
1865          * hardreset if no device is attached to the first downstream
1866          * port && the pseudo device locks up on SRST w/ PMP==0.  To
1867          * work around this, wait for !BSY only briefly.  If BSY isn't
1868          * cleared, perform CLO and proceed to IDENTIFY (achieved by
1869          * ATA_LFLAG_NO_SRST and ATA_LFLAG_ASSUME_ATA).
1870          *
1871          * Wait for two seconds.  Devices attached to downstream port
1872          * which can't process the following IDENTIFY after this will
1873          * have to be reset again.  For most cases, this should
1874          * suffice while making probing snappish enough.
1875          */
1876         if (online) {
1877                 rc = ata_wait_after_reset(link, jiffies + 2 * HZ,
1878                                           ahci_check_ready);
1879                 if (rc)
1880                         ahci_kick_engine(ap, 0);
1881         }
1882         return rc;
1883 }
1884
1885 static void ahci_postreset(struct ata_link *link, unsigned int *class)
1886 {
1887         struct ata_port *ap = link->ap;
1888         void __iomem *port_mmio = ahci_port_base(ap);
1889         u32 new_tmp, tmp;
1890
1891         ata_std_postreset(link, class);
1892
1893         /* Make sure port's ATAPI bit is set appropriately */
1894         new_tmp = tmp = readl(port_mmio + PORT_CMD);
1895         if (*class == ATA_DEV_ATAPI)
1896                 new_tmp |= PORT_CMD_ATAPI;
1897         else
1898                 new_tmp &= ~PORT_CMD_ATAPI;
1899         if (new_tmp != tmp) {
1900                 writel(new_tmp, port_mmio + PORT_CMD);
1901                 readl(port_mmio + PORT_CMD); /* flush */
1902         }
1903 }
1904
1905 static unsigned int ahci_fill_sg(struct ata_queued_cmd *qc, void *cmd_tbl)
1906 {
1907         struct scatterlist *sg;
1908         struct ahci_sg *ahci_sg = cmd_tbl + AHCI_CMD_TBL_HDR_SZ;
1909         unsigned int si;
1910
1911         VPRINTK("ENTER\n");
1912
1913         /*
1914          * Next, the S/G list.
1915          */
1916         for_each_sg(qc->sg, sg, qc->n_elem, si) {
1917                 dma_addr_t addr = sg_dma_address(sg);
1918                 u32 sg_len = sg_dma_len(sg);
1919
1920                 ahci_sg[si].addr = cpu_to_le32(addr & 0xffffffff);
1921                 ahci_sg[si].addr_hi = cpu_to_le32((addr >> 16) >> 16);
1922                 ahci_sg[si].flags_size = cpu_to_le32(sg_len - 1);
1923         }
1924
1925         return si;
1926 }
1927
1928 static void ahci_qc_prep(struct ata_queued_cmd *qc)
1929 {
1930         struct ata_port *ap = qc->ap;
1931         struct ahci_port_priv *pp = ap->private_data;
1932         int is_atapi = ata_is_atapi(qc->tf.protocol);
1933         void *cmd_tbl;
1934         u32 opts;
1935         const u32 cmd_fis_len = 5; /* five dwords */
1936         unsigned int n_elem;
1937
1938         /*
1939          * Fill in command table information.  First, the header,
1940          * a SATA Register - Host to Device command FIS.
1941          */
1942         cmd_tbl = pp->cmd_tbl + qc->tag * AHCI_CMD_TBL_SZ;
1943
1944         ata_tf_to_fis(&qc->tf, qc->dev->link->pmp, 1, cmd_tbl);
1945         if (is_atapi) {
1946                 memset(cmd_tbl + AHCI_CMD_TBL_CDB, 0, 32);
1947                 memcpy(cmd_tbl + AHCI_CMD_TBL_CDB, qc->cdb, qc->dev->cdb_len);
1948         }
1949
1950         n_elem = 0;
1951         if (qc->flags & ATA_QCFLAG_DMAMAP)
1952                 n_elem = ahci_fill_sg(qc, cmd_tbl);
1953
1954         /*
1955          * Fill in command slot information.
1956          */
1957         opts = cmd_fis_len | n_elem << 16 | (qc->dev->link->pmp << 12);
1958         if (qc->tf.flags & ATA_TFLAG_WRITE)
1959                 opts |= AHCI_CMD_WRITE;
1960         if (is_atapi)
1961                 opts |= AHCI_CMD_ATAPI | AHCI_CMD_PREFETCH;
1962
1963         ahci_fill_cmd_slot(pp, qc->tag, opts);
1964 }
1965
1966 static void ahci_error_intr(struct ata_port *ap, u32 irq_stat)
1967 {
1968         struct ahci_host_priv *hpriv = ap->host->private_data;
1969         struct ahci_port_priv *pp = ap->private_data;
1970         struct ata_eh_info *host_ehi = &ap->link.eh_info;
1971         struct ata_link *link = NULL;
1972         struct ata_queued_cmd *active_qc;
1973         struct ata_eh_info *active_ehi;
1974         u32 serror;
1975
1976         /* determine active link */
1977         ata_for_each_link(link, ap, EDGE)
1978                 if (ata_link_active(link))
1979                         break;
1980         if (!link)
1981                 link = &ap->link;
1982
1983         active_qc = ata_qc_from_tag(ap, link->active_tag);
1984         active_ehi = &link->eh_info;
1985
1986         /* record irq stat */
1987         ata_ehi_clear_desc(host_ehi);
1988         ata_ehi_push_desc(host_ehi, "irq_stat 0x%08x", irq_stat);
1989
1990         /* AHCI needs SError cleared; otherwise, it might lock up */
1991         ahci_scr_read(&ap->link, SCR_ERROR, &serror);
1992         ahci_scr_write(&ap->link, SCR_ERROR, serror);
1993         host_ehi->serror |= serror;
1994
1995         /* some controllers set IRQ_IF_ERR on device errors, ignore it */
1996         if (hpriv->flags & AHCI_HFLAG_IGN_IRQ_IF_ERR)
1997                 irq_stat &= ~PORT_IRQ_IF_ERR;
1998
1999         if (irq_stat & PORT_IRQ_TF_ERR) {
2000                 /* If qc is active, charge it; otherwise, the active
2001                  * link.  There's no active qc on NCQ errors.  It will
2002                  * be determined by EH by reading log page 10h.
2003                  */
2004                 if (active_qc)
2005                         active_qc->err_mask |= AC_ERR_DEV;
2006                 else
2007                         active_ehi->err_mask |= AC_ERR_DEV;
2008
2009                 if (hpriv->flags & AHCI_HFLAG_IGN_SERR_INTERNAL)
2010                         host_ehi->serror &= ~SERR_INTERNAL;
2011         }
2012
2013         if (irq_stat & PORT_IRQ_UNK_FIS) {
2014                 u32 *unk = (u32 *)(pp->rx_fis + RX_FIS_UNK);
2015
2016                 active_ehi->err_mask |= AC_ERR_HSM;
2017                 active_ehi->action |= ATA_EH_RESET;
2018                 ata_ehi_push_desc(active_ehi,
2019                                   "unknown FIS %08x %08x %08x %08x" ,
2020                                   unk[0], unk[1], unk[2], unk[3]);
2021         }
2022
2023         if (sata_pmp_attached(ap) && (irq_stat & PORT_IRQ_BAD_PMP)) {
2024                 active_ehi->err_mask |= AC_ERR_HSM;
2025                 active_ehi->action |= ATA_EH_RESET;
2026                 ata_ehi_push_desc(active_ehi, "incorrect PMP");
2027         }
2028
2029         if (irq_stat & (PORT_IRQ_HBUS_ERR | PORT_IRQ_HBUS_DATA_ERR)) {
2030                 host_ehi->err_mask |= AC_ERR_HOST_BUS;
2031                 host_ehi->action |= ATA_EH_RESET;
2032                 ata_ehi_push_desc(host_ehi, "host bus error");
2033         }
2034
2035         if (irq_stat & PORT_IRQ_IF_ERR) {
2036                 host_ehi->err_mask |= AC_ERR_ATA_BUS;
2037                 host_ehi->action |= ATA_EH_RESET;
2038                 ata_ehi_push_desc(host_ehi, "interface fatal error");
2039         }
2040
2041         if (irq_stat & (PORT_IRQ_CONNECT | PORT_IRQ_PHYRDY)) {
2042                 ata_ehi_hotplugged(host_ehi);
2043                 ata_ehi_push_desc(host_ehi, "%s",
2044                         irq_stat & PORT_IRQ_CONNECT ?
2045                         "connection status changed" : "PHY RDY changed");
2046         }
2047
2048         /* okay, let's hand over to EH */
2049
2050         if (irq_stat & PORT_IRQ_FREEZE)
2051                 ata_port_freeze(ap);
2052         else
2053                 ata_port_abort(ap);
2054 }
2055
2056 static void ahci_port_intr(struct ata_port *ap)
2057 {
2058         void __iomem *port_mmio = ahci_port_base(ap);
2059         struct ata_eh_info *ehi = &ap->link.eh_info;
2060         struct ahci_port_priv *pp = ap->private_data;
2061         struct ahci_host_priv *hpriv = ap->host->private_data;
2062         int resetting = !!(ap->pflags & ATA_PFLAG_RESETTING);
2063         u32 status, qc_active;
2064         int rc;
2065
2066         status = readl(port_mmio + PORT_IRQ_STAT);
2067         writel(status, port_mmio + PORT_IRQ_STAT);
2068
2069         /* ignore BAD_PMP while resetting */
2070         if (unlikely(resetting))
2071                 status &= ~PORT_IRQ_BAD_PMP;
2072
2073         /* If we are getting PhyRdy, this is
2074          * just a power state change, we should
2075          * clear out this, plus the PhyRdy/Comm
2076          * Wake bits from Serror
2077          */
2078         if ((hpriv->flags & AHCI_HFLAG_NO_HOTPLUG) &&
2079                 (status & PORT_IRQ_PHYRDY)) {
2080                 status &= ~PORT_IRQ_PHYRDY;
2081                 ahci_scr_write(&ap->link, SCR_ERROR, ((1 << 16) | (1 << 18)));
2082         }
2083
2084         if (unlikely(status & PORT_IRQ_ERROR)) {
2085                 ahci_error_intr(ap, status);
2086                 return;
2087         }
2088
2089         if (status & PORT_IRQ_SDB_FIS) {
2090                 /* If SNotification is available, leave notification
2091                  * handling to sata_async_notification().  If not,
2092                  * emulate it by snooping SDB FIS RX area.
2093                  *
2094                  * Snooping FIS RX area is probably cheaper than
2095                  * poking SNotification but some constrollers which
2096                  * implement SNotification, ICH9 for example, don't
2097                  * store AN SDB FIS into receive area.
2098                  */
2099                 if (hpriv->cap & HOST_CAP_SNTF)
2100                         sata_async_notification(ap);
2101                 else {
2102                         /* If the 'N' bit in word 0 of the FIS is set,
2103                          * we just received asynchronous notification.
2104                          * Tell libata about it.
2105                          */
2106                         const __le32 *f = pp->rx_fis + RX_FIS_SDB;
2107                         u32 f0 = le32_to_cpu(f[0]);
2108
2109                         if (f0 & (1 << 15))
2110                                 sata_async_notification(ap);
2111                 }
2112         }
2113
2114         /* pp->active_link is valid iff any command is in flight */
2115         if (ap->qc_active && pp->active_link->sactive)
2116                 qc_active = readl(port_mmio + PORT_SCR_ACT);
2117         else
2118                 qc_active = readl(port_mmio + PORT_CMD_ISSUE);
2119
2120         rc = ata_qc_complete_multiple(ap, qc_active);
2121
2122         /* while resetting, invalid completions are expected */
2123         if (unlikely(rc < 0 && !resetting)) {
2124                 ehi->err_mask |= AC_ERR_HSM;
2125                 ehi->action |= ATA_EH_RESET;
2126                 ata_port_freeze(ap);
2127         }
2128 }
2129
2130 static irqreturn_t ahci_interrupt(int irq, void *dev_instance)
2131 {
2132         struct ata_host *host = dev_instance;
2133         struct ahci_host_priv *hpriv;
2134         unsigned int i, handled = 0;
2135         void __iomem *mmio;
2136         u32 irq_stat, irq_masked;
2137
2138         VPRINTK("ENTER\n");
2139
2140         hpriv = host->private_data;
2141         mmio = host->iomap[AHCI_PCI_BAR];
2142
2143         /* sigh.  0xffffffff is a valid return from h/w */
2144         irq_stat = readl(mmio + HOST_IRQ_STAT);
2145         if (!irq_stat)
2146                 return IRQ_NONE;
2147
2148         irq_masked = irq_stat & hpriv->port_map;
2149
2150         spin_lock(&host->lock);
2151
2152         for (i = 0; i < host->n_ports; i++) {
2153                 struct ata_port *ap;
2154
2155                 if (!(irq_masked & (1 << i)))
2156                         continue;
2157
2158                 ap = host->ports[i];
2159                 if (ap) {
2160                         ahci_port_intr(ap);
2161                         VPRINTK("port %u\n", i);
2162                 } else {
2163                         VPRINTK("port %u (no irq)\n", i);
2164                         if (ata_ratelimit())
2165                                 dev_printk(KERN_WARNING, host->dev,
2166                                         "interrupt on disabled port %u\n", i);
2167                 }
2168
2169                 handled = 1;
2170         }
2171
2172         /* HOST_IRQ_STAT behaves as level triggered latch meaning that
2173          * it should be cleared after all the port events are cleared;
2174          * otherwise, it will raise a spurious interrupt after each
2175          * valid one.  Please read section 10.6.2 of ahci 1.1 for more
2176          * information.
2177          *
2178          * Also, use the unmasked value to clear interrupt as spurious
2179          * pending event on a dummy port might cause screaming IRQ.
2180          */
2181         writel(irq_stat, mmio + HOST_IRQ_STAT);
2182
2183         spin_unlock(&host->lock);
2184
2185         VPRINTK("EXIT\n");
2186
2187         return IRQ_RETVAL(handled);
2188 }
2189
2190 static unsigned int ahci_qc_issue(struct ata_queued_cmd *qc)
2191 {
2192         struct ata_port *ap = qc->ap;
2193         void __iomem *port_mmio = ahci_port_base(ap);
2194         struct ahci_port_priv *pp = ap->private_data;
2195
2196         /* Keep track of the currently active link.  It will be used
2197          * in completion path to determine whether NCQ phase is in
2198          * progress.
2199          */
2200         pp->active_link = qc->dev->link;
2201
2202         if (qc->tf.protocol == ATA_PROT_NCQ)
2203                 writel(1 << qc->tag, port_mmio + PORT_SCR_ACT);
2204         writel(1 << qc->tag, port_mmio + PORT_CMD_ISSUE);
2205
2206         ahci_sw_activity(qc->dev->link);
2207
2208         return 0;
2209 }
2210
2211 static bool ahci_qc_fill_rtf(struct ata_queued_cmd *qc)
2212 {
2213         struct ahci_port_priv *pp = qc->ap->private_data;
2214         u8 *d2h_fis = pp->rx_fis + RX_FIS_D2H_REG;
2215
2216         ata_tf_from_fis(d2h_fis, &qc->result_tf);
2217         return true;
2218 }
2219
2220 static void ahci_freeze(struct ata_port *ap)
2221 {
2222         void __iomem *port_mmio = ahci_port_base(ap);
2223
2224         /* turn IRQ off */
2225         writel(0, port_mmio + PORT_IRQ_MASK);
2226 }
2227
2228 static void ahci_thaw(struct ata_port *ap)
2229 {
2230         void __iomem *mmio = ap->host->iomap[AHCI_PCI_BAR];
2231         void __iomem *port_mmio = ahci_port_base(ap);
2232         u32 tmp;
2233         struct ahci_port_priv *pp = ap->private_data;
2234
2235         /* clear IRQ */
2236         tmp = readl(port_mmio + PORT_IRQ_STAT);
2237         writel(tmp, port_mmio + PORT_IRQ_STAT);
2238         writel(1 << ap->port_no, mmio + HOST_IRQ_STAT);
2239
2240         /* turn IRQ back on */
2241         writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK);
2242 }
2243
2244 static void ahci_error_handler(struct ata_port *ap)
2245 {
2246         if (!(ap->pflags & ATA_PFLAG_FROZEN)) {
2247                 /* restart engine */
2248                 ahci_stop_engine(ap);
2249                 ahci_start_engine(ap);
2250         }
2251
2252         sata_pmp_error_handler(ap);
2253 }
2254
2255 static void ahci_post_internal_cmd(struct ata_queued_cmd *qc)
2256 {
2257         struct ata_port *ap = qc->ap;
2258
2259         /* make DMA engine forget about the failed command */
2260         if (qc->flags & ATA_QCFLAG_FAILED)
2261                 ahci_kick_engine(ap, 1);
2262 }
2263
2264 static void ahci_pmp_attach(struct ata_port *ap)
2265 {
2266         void __iomem *port_mmio = ahci_port_base(ap);
2267         struct ahci_port_priv *pp = ap->private_data;
2268         u32 cmd;
2269
2270         cmd = readl(port_mmio + PORT_CMD);
2271         cmd |= PORT_CMD_PMP;
2272         writel(cmd, port_mmio + PORT_CMD);
2273
2274         pp->intr_mask |= PORT_IRQ_BAD_PMP;
2275         writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK);
2276 }
2277
2278 static void ahci_pmp_detach(struct ata_port *ap)
2279 {
2280         void __iomem *port_mmio = ahci_port_base(ap);
2281         struct ahci_port_priv *pp = ap->private_data;
2282         u32 cmd;
2283
2284         cmd = readl(port_mmio + PORT_CMD);
2285         cmd &= ~PORT_CMD_PMP;
2286         writel(cmd, port_mmio + PORT_CMD);
2287
2288         pp->intr_mask &= ~PORT_IRQ_BAD_PMP;
2289         writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK);
2290 }
2291
2292 static int ahci_port_resume(struct ata_port *ap)
2293 {
2294         ahci_power_up(ap);
2295         ahci_start_port(ap);
2296
2297         if (sata_pmp_attached(ap))
2298                 ahci_pmp_attach(ap);
2299         else
2300                 ahci_pmp_detach(ap);
2301
2302         return 0;
2303 }
2304
2305 #ifdef CONFIG_PM
2306 static int ahci_port_suspend(struct ata_port *ap, pm_message_t mesg)
2307 {
2308         const char *emsg = NULL;
2309         int rc;
2310
2311         rc = ahci_deinit_port(ap, &emsg);
2312         if (rc == 0)
2313                 ahci_power_down(ap);
2314         else {
2315                 ata_port_printk(ap, KERN_ERR, "%s (%d)\n", emsg, rc);
2316                 ahci_start_port(ap);
2317         }
2318
2319         return rc;
2320 }
2321
2322 static int ahci_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg)
2323 {
2324         struct ata_host *host = dev_get_drvdata(&pdev->dev);
2325         struct ahci_host_priv *hpriv = host->private_data;
2326         void __iomem *mmio = host->iomap[AHCI_PCI_BAR];
2327         u32 ctl;
2328
2329         if (mesg.event & PM_EVENT_SUSPEND &&
2330             hpriv->flags & AHCI_HFLAG_NO_SUSPEND) {
2331                 dev_printk(KERN_ERR, &pdev->dev,
2332                            "BIOS update required for suspend/resume\n");
2333                 return -EIO;
2334         }
2335
2336         if (mesg.event & PM_EVENT_SLEEP) {
2337                 /* AHCI spec rev1.1 section 8.3.3:
2338                  * Software must disable interrupts prior to requesting a
2339                  * transition of the HBA to D3 state.
2340                  */
2341                 ctl = readl(mmio + HOST_CTL);
2342                 ctl &= ~HOST_IRQ_EN;
2343                 writel(ctl, mmio + HOST_CTL);
2344                 readl(mmio + HOST_CTL); /* flush */
2345         }
2346
2347         return ata_pci_device_suspend(pdev, mesg);
2348 }
2349
2350 static int ahci_pci_device_resume(struct pci_dev *pdev)
2351 {
2352         struct ata_host *host = dev_get_drvdata(&pdev->dev);
2353         int rc;
2354
2355         rc = ata_pci_device_do_resume(pdev);
2356         if (rc)
2357                 return rc;
2358
2359         if (pdev->dev.power.power_state.event == PM_EVENT_SUSPEND) {
2360                 rc = ahci_reset_controller(host);
2361                 if (rc)
2362                         return rc;
2363
2364                 ahci_init_controller(host);
2365         }
2366
2367         ata_host_resume(host);
2368
2369         return 0;
2370 }
2371 #endif
2372
2373 static int ahci_port_start(struct ata_port *ap)
2374 {
2375         struct device *dev = ap->host->dev;
2376         struct ahci_port_priv *pp;
2377         void *mem;
2378         dma_addr_t mem_dma;
2379
2380         pp = devm_kzalloc(dev, sizeof(*pp), GFP_KERNEL);
2381         if (!pp)
2382                 return -ENOMEM;
2383
2384         mem = dmam_alloc_coherent(dev, AHCI_PORT_PRIV_DMA_SZ, &mem_dma,
2385                                   GFP_KERNEL);
2386         if (!mem)
2387                 return -ENOMEM;
2388         memset(mem, 0, AHCI_PORT_PRIV_DMA_SZ);
2389
2390         /*
2391          * First item in chunk of DMA memory: 32-slot command table,
2392          * 32 bytes each in size
2393          */
2394         pp->cmd_slot = mem;
2395         pp->cmd_slot_dma = mem_dma;
2396
2397         mem += AHCI_CMD_SLOT_SZ;
2398         mem_dma += AHCI_CMD_SLOT_SZ;
2399
2400         /*
2401          * Second item: Received-FIS area
2402          */
2403         pp->rx_fis = mem;
2404         pp->rx_fis_dma = mem_dma;
2405
2406         mem += AHCI_RX_FIS_SZ;
2407         mem_dma += AHCI_RX_FIS_SZ;
2408
2409         /*
2410          * Third item: data area for storing a single command
2411          * and its scatter-gather table
2412          */
2413         pp->cmd_tbl = mem;
2414         pp->cmd_tbl_dma = mem_dma;
2415
2416         /*
2417          * Save off initial list of interrupts to be enabled.
2418          * This could be changed later
2419          */
2420         pp->intr_mask = DEF_PORT_IRQ;
2421
2422         ap->private_data = pp;
2423
2424         /* engage engines, captain */
2425         return ahci_port_resume(ap);
2426 }
2427
2428 static void ahci_port_stop(struct ata_port *ap)
2429 {
2430         const char *emsg = NULL;
2431         int rc;
2432
2433         /* de-initialize port */
2434         rc = ahci_deinit_port(ap, &emsg);
2435         if (rc)
2436                 ata_port_printk(ap, KERN_WARNING, "%s (%d)\n", emsg, rc);
2437 }
2438
2439 static int ahci_configure_dma_masks(struct pci_dev *pdev, int using_dac)
2440 {
2441         int rc;
2442
2443         if (using_dac &&
2444             !pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
2445                 rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
2446                 if (rc) {
2447                         rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
2448                         if (rc) {
2449                                 dev_printk(KERN_ERR, &pdev->dev,
2450                                            "64-bit DMA enable failed\n");
2451                                 return rc;
2452                         }
2453                 }
2454         } else {
2455                 rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
2456                 if (rc) {
2457                         dev_printk(KERN_ERR, &pdev->dev,
2458                                    "32-bit DMA enable failed\n");
2459                         return rc;
2460                 }
2461                 rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
2462                 if (rc) {
2463                         dev_printk(KERN_ERR, &pdev->dev,
2464                                    "32-bit consistent DMA enable failed\n");
2465                         return rc;
2466                 }
2467         }
2468         return 0;
2469 }
2470
2471 static void ahci_print_info(struct ata_host *host)
2472 {
2473         struct ahci_host_priv *hpriv = host->private_data;
2474         struct pci_dev *pdev = to_pci_dev(host->dev);
2475         void __iomem *mmio = host->iomap[AHCI_PCI_BAR];
2476         u32 vers, cap, impl, speed;
2477         const char *speed_s;
2478         u16 cc;
2479         const char *scc_s;
2480
2481         vers = readl(mmio + HOST_VERSION);
2482         cap = hpriv->cap;
2483         impl = hpriv->port_map;
2484
2485         speed = (cap >> 20) & 0xf;
2486         if (speed == 1)
2487                 speed_s = "1.5";
2488         else if (speed == 2)
2489                 speed_s = "3";
2490         else if (speed == 3)
2491                 speed_s = "6";
2492         else
2493                 speed_s = "?";
2494
2495         pci_read_config_word(pdev, 0x0a, &cc);
2496         if (cc == PCI_CLASS_STORAGE_IDE)
2497                 scc_s = "IDE";
2498         else if (cc == PCI_CLASS_STORAGE_SATA)
2499                 scc_s = "SATA";
2500         else if (cc == PCI_CLASS_STORAGE_RAID)
2501                 scc_s = "RAID";
2502         else
2503                 scc_s = "unknown";
2504
2505         dev_printk(KERN_INFO, &pdev->dev,
2506                 "AHCI %02x%02x.%02x%02x "
2507                 "%u slots %u ports %s Gbps 0x%x impl %s mode\n"
2508                 ,
2509
2510                 (vers >> 24) & 0xff,
2511                 (vers >> 16) & 0xff,
2512                 (vers >> 8) & 0xff,
2513                 vers & 0xff,
2514
2515                 ((cap >> 8) & 0x1f) + 1,
2516                 (cap & 0x1f) + 1,
2517                 speed_s,
2518                 impl,
2519                 scc_s);
2520
2521         dev_printk(KERN_INFO, &pdev->dev,
2522                 "flags: "
2523                 "%s%s%s%s%s%s%s"
2524                 "%s%s%s%s%s%s%s"
2525                 "%s\n"
2526                 ,
2527
2528                 cap & (1 << 31) ? "64bit " : "",
2529                 cap & (1 << 30) ? "ncq " : "",
2530                 cap & (1 << 29) ? "sntf " : "",
2531                 cap & (1 << 28) ? "ilck " : "",
2532                 cap & (1 << 27) ? "stag " : "",
2533                 cap & (1 << 26) ? "pm " : "",
2534                 cap & (1 << 25) ? "led " : "",
2535
2536                 cap & (1 << 24) ? "clo " : "",
2537                 cap & (1 << 19) ? "nz " : "",
2538                 cap & (1 << 18) ? "only " : "",
2539                 cap & (1 << 17) ? "pmp " : "",
2540                 cap & (1 << 15) ? "pio " : "",
2541                 cap & (1 << 14) ? "slum " : "",
2542                 cap & (1 << 13) ? "part " : "",
2543                 cap & (1 << 6) ? "ems ": ""
2544                 );
2545 }
2546
2547 /* On ASUS P5W DH Deluxe, the second port of PCI device 00:1f.2 is
2548  * hardwired to on-board SIMG 4726.  The chipset is ICH8 and doesn't
2549  * support PMP and the 4726 either directly exports the device
2550  * attached to the first downstream port or acts as a hardware storage
2551  * controller and emulate a single ATA device (can be RAID 0/1 or some
2552  * other configuration).
2553  *
2554  * When there's no device attached to the first downstream port of the
2555  * 4726, "Config Disk" appears, which is a pseudo ATA device to
2556  * configure the 4726.  However, ATA emulation of the device is very
2557  * lame.  It doesn't send signature D2H Reg FIS after the initial
2558  * hardreset, pukes on SRST w/ PMP==0 and has bunch of other issues.
2559  *
2560  * The following function works around the problem by always using
2561  * hardreset on the port and not depending on receiving signature FIS
2562  * afterward.  If signature FIS isn't received soon, ATA class is
2563  * assumed without follow-up softreset.
2564  */
2565 static void ahci_p5wdh_workaround(struct ata_host *host)
2566 {
2567         static struct dmi_system_id sysids[] = {
2568                 {
2569                         .ident = "P5W DH Deluxe",
2570                         .matches = {
2571                                 DMI_MATCH(DMI_SYS_VENDOR,
2572                                           "ASUSTEK COMPUTER INC"),
2573                                 DMI_MATCH(DMI_PRODUCT_NAME, "P5W DH Deluxe"),
2574                         },
2575                 },
2576                 { }
2577         };
2578         struct pci_dev *pdev = to_pci_dev(host->dev);
2579
2580         if (pdev->bus->number == 0 && pdev->devfn == PCI_DEVFN(0x1f, 2) &&
2581             dmi_check_system(sysids)) {
2582                 struct ata_port *ap = host->ports[1];
2583
2584                 dev_printk(KERN_INFO, &pdev->dev, "enabling ASUS P5W DH "
2585                            "Deluxe on-board SIMG4726 workaround\n");
2586
2587                 ap->ops = &ahci_p5wdh_ops;
2588                 ap->link.flags |= ATA_LFLAG_NO_SRST | ATA_LFLAG_ASSUME_ATA;
2589         }
2590 }
2591
2592 /*
2593  * SB600 ahci controller on ASUS M2A-VM can't do 64bit DMA with older
2594  * BIOS.  The oldest version known to be broken is 0901 and working is
2595  * 1501 which was released on 2007-10-26.  Force 32bit DMA on anything
2596  * older than 1501.  Please read bko#9412 for more info.
2597  */
2598 static bool ahci_asus_m2a_vm_32bit_only(struct pci_dev *pdev)
2599 {
2600         static const struct dmi_system_id sysids[] = {
2601                 {
2602                         .ident = "ASUS M2A-VM",
2603                         .matches = {
2604                                 DMI_MATCH(DMI_BOARD_VENDOR,
2605                                           "ASUSTeK Computer INC."),
2606                                 DMI_MATCH(DMI_BOARD_NAME, "M2A-VM"),
2607                         },
2608                 },
2609                 { }
2610         };
2611         const char *cutoff_mmdd = "10/26";
2612         const char *date;
2613         int year;
2614
2615         if (pdev->bus->number != 0 || pdev->devfn != PCI_DEVFN(0x12, 0) ||
2616             !dmi_check_system(sysids))
2617                 return false;
2618
2619         /*
2620          * Argh.... both version and date are free form strings.
2621          * Let's hope they're using the same date format across
2622          * different versions.
2623          */
2624         date = dmi_get_system_info(DMI_BIOS_DATE);
2625         year = dmi_get_year(DMI_BIOS_DATE);
2626         if (date && strlen(date) >= 10 && date[2] == '/' && date[5] == '/' &&
2627             (year > 2007 ||
2628              (year == 2007 && strncmp(date, cutoff_mmdd, 5) >= 0)))
2629                 return false;
2630
2631         dev_printk(KERN_WARNING, &pdev->dev, "ASUS M2A-VM: BIOS too old, "
2632                    "forcing 32bit DMA, update BIOS\n");
2633
2634         return true;
2635 }
2636
2637 static bool ahci_broken_system_poweroff(struct pci_dev *pdev)
2638 {
2639         static const struct dmi_system_id broken_systems[] = {
2640                 {
2641                         .ident = "HP Compaq nx6310",
2642                         .matches = {
2643                                 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
2644                                 DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq nx6310"),
2645                         },
2646                         /* PCI slot number of the controller */
2647                         .driver_data = (void *)0x1FUL,
2648                 },
2649                 {
2650                         .ident = "HP Compaq 6720s",
2651                         .matches = {
2652                                 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
2653                                 DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq 6720s"),
2654                         },
2655                         /* PCI slot number of the controller */
2656                         .driver_data = (void *)0x1FUL,
2657                 },
2658
2659                 { }     /* terminate list */
2660         };
2661         const struct dmi_system_id *dmi = dmi_first_match(broken_systems);
2662
2663         if (dmi) {
2664                 unsigned long slot = (unsigned long)dmi->driver_data;
2665                 /* apply the quirk only to on-board controllers */
2666                 return slot == PCI_SLOT(pdev->devfn);
2667         }
2668
2669         return false;
2670 }
2671
2672 static bool ahci_broken_suspend(struct pci_dev *pdev)
2673 {
2674         static const struct dmi_system_id sysids[] = {
2675                 /*
2676                  * On HP dv[4-6] and HDX18 with earlier BIOSen, link
2677                  * to the harddisk doesn't become online after
2678                  * resuming from STR.  Warn and fail suspend.
2679                  */
2680                 {
2681                         .ident = "dv4",
2682                         .matches = {
2683                                 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
2684                                 DMI_MATCH(DMI_PRODUCT_NAME,
2685                                           "HP Pavilion dv4 Notebook PC"),
2686                         },
2687                         .driver_data = "F.30", /* cutoff BIOS version */
2688                 },
2689                 {
2690                         .ident = "dv5",
2691                         .matches = {
2692                                 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
2693                                 DMI_MATCH(DMI_PRODUCT_NAME,
2694                                           "HP Pavilion dv5 Notebook PC"),
2695                         },
2696                         .driver_data = "F.16", /* cutoff BIOS version */
2697                 },
2698                 {
2699                         .ident = "dv6",
2700                         .matches = {
2701                                 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
2702                                 DMI_MATCH(DMI_PRODUCT_NAME,
2703                                           "HP Pavilion dv6 Notebook PC"),
2704                         },
2705                         .driver_data = "F.21",  /* cutoff BIOS version */
2706                 },
2707                 {
2708                         .ident = "HDX18",
2709                         .matches = {
2710                                 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
2711                                 DMI_MATCH(DMI_PRODUCT_NAME,
2712                                           "HP HDX18 Notebook PC"),
2713                         },
2714                         .driver_data = "F.23",  /* cutoff BIOS version */
2715                 },
2716                 { }     /* terminate list */
2717         };
2718         const struct dmi_system_id *dmi = dmi_first_match(sysids);
2719         const char *ver;
2720
2721         if (!dmi || pdev->bus->number || pdev->devfn != PCI_DEVFN(0x1f, 2))
2722                 return false;
2723
2724         ver = dmi_get_system_info(DMI_BIOS_VERSION);
2725
2726         return !ver || strcmp(ver, dmi->driver_data) < 0;
2727 }
2728
2729 static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
2730 {
2731         static int printed_version;
2732         unsigned int board_id = ent->driver_data;
2733         struct ata_port_info pi = ahci_port_info[board_id];
2734         const struct ata_port_info *ppi[] = { &pi, NULL };
2735         struct device *dev = &pdev->dev;
2736         struct ahci_host_priv *hpriv;
2737         struct ata_host *host;
2738         int n_ports, i, rc;
2739
2740         VPRINTK("ENTER\n");
2741
2742         WARN_ON(ATA_MAX_QUEUE > AHCI_MAX_CMDS);
2743
2744         if (!printed_version++)
2745                 dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
2746
2747         /* The AHCI driver can only drive the SATA ports, the PATA driver
2748            can drive them all so if both drivers are selected make sure
2749            AHCI stays out of the way */
2750         if (pdev->vendor == PCI_VENDOR_ID_MARVELL && !marvell_enable)
2751                 return -ENODEV;
2752
2753         /* acquire resources */
2754         rc = pcim_enable_device(pdev);
2755         if (rc)
2756                 return rc;
2757
2758         /* AHCI controllers often implement SFF compatible interface.
2759          * Grab all PCI BARs just in case.
2760          */
2761         rc = pcim_iomap_regions_request_all(pdev, 1 << AHCI_PCI_BAR, DRV_NAME);
2762         if (rc == -EBUSY)
2763                 pcim_pin_device(pdev);
2764         if (rc)
2765                 return rc;
2766
2767         if (pdev->vendor == PCI_VENDOR_ID_INTEL &&
2768             (pdev->device == 0x2652 || pdev->device == 0x2653)) {
2769                 u8 map;
2770
2771                 /* ICH6s share the same PCI ID for both piix and ahci
2772                  * modes.  Enabling ahci mode while MAP indicates
2773                  * combined mode is a bad idea.  Yield to ata_piix.
2774                  */
2775                 pci_read_config_byte(pdev, ICH_MAP, &map);
2776                 if (map & 0x3) {
2777                         dev_printk(KERN_INFO, &pdev->dev, "controller is in "
2778                                    "combined mode, can't enable AHCI mode\n");
2779                         return -ENODEV;
2780                 }
2781         }
2782
2783         hpriv = devm_kzalloc(dev, sizeof(*hpriv), GFP_KERNEL);
2784         if (!hpriv)
2785                 return -ENOMEM;
2786         hpriv->flags |= (unsigned long)pi.private_data;
2787
2788         /* MCP65 revision A1 and A2 can't do MSI */
2789         if (board_id == board_ahci_mcp65 &&
2790             (pdev->revision == 0xa1 || pdev->revision == 0xa2))
2791                 hpriv->flags |= AHCI_HFLAG_NO_MSI;
2792
2793         /* SB800 does NOT need the workaround to ignore SERR_INTERNAL */
2794         if (board_id == board_ahci_sb700 && pdev->revision >= 0x40)
2795                 hpriv->flags &= ~AHCI_HFLAG_IGN_SERR_INTERNAL;
2796
2797         /* apply ASUS M2A_VM quirk */
2798         if (ahci_asus_m2a_vm_32bit_only(pdev))
2799                 hpriv->flags |= AHCI_HFLAG_32BIT_ONLY;
2800
2801         if (!(hpriv->flags & AHCI_HFLAG_NO_MSI))
2802                 pci_enable_msi(pdev);
2803
2804         /* save initial config */
2805         ahci_save_initial_config(pdev, hpriv);
2806
2807         /* prepare host */
2808         if (hpriv->cap & HOST_CAP_NCQ)
2809                 pi.flags |= ATA_FLAG_NCQ;
2810
2811         if (hpriv->cap & HOST_CAP_PMP)
2812                 pi.flags |= ATA_FLAG_PMP;
2813
2814         if (ahci_em_messages && (hpriv->cap & HOST_CAP_EMS)) {
2815                 u8 messages;
2816                 void __iomem *mmio = pcim_iomap_table(pdev)[AHCI_PCI_BAR];
2817                 u32 em_loc = readl(mmio + HOST_EM_LOC);
2818                 u32 em_ctl = readl(mmio + HOST_EM_CTL);
2819
2820                 messages = (em_ctl & EM_CTRL_MSG_TYPE) >> 16;
2821
2822                 /* we only support LED message type right now */
2823                 if ((messages & 0x01) && (ahci_em_messages == 1)) {
2824                         /* store em_loc */
2825                         hpriv->em_loc = ((em_loc >> 16) * 4);
2826                         pi.flags |= ATA_FLAG_EM;
2827                         if (!(em_ctl & EM_CTL_ALHD))
2828                                 pi.flags |= ATA_FLAG_SW_ACTIVITY;
2829                 }
2830         }
2831
2832         if (ahci_broken_system_poweroff(pdev)) {
2833                 pi.flags |= ATA_FLAG_NO_POWEROFF_SPINDOWN;
2834                 dev_info(&pdev->dev,
2835                         "quirky BIOS, skipping spindown on poweroff\n");
2836         }
2837
2838         if (ahci_broken_suspend(pdev)) {
2839                 hpriv->flags |= AHCI_HFLAG_NO_SUSPEND;
2840                 dev_printk(KERN_WARNING, &pdev->dev,
2841                            "BIOS update required for suspend/resume\n");
2842         }
2843
2844         /* CAP.NP sometimes indicate the index of the last enabled
2845          * port, at other times, that of the last possible port, so
2846          * determining the maximum port number requires looking at
2847          * both CAP.NP and port_map.
2848          */
2849         n_ports = max(ahci_nr_ports(hpriv->cap), fls(hpriv->port_map));
2850
2851         host = ata_host_alloc_pinfo(&pdev->dev, ppi, n_ports);
2852         if (!host)
2853                 return -ENOMEM;
2854         host->iomap = pcim_iomap_table(pdev);
2855         host->private_data = hpriv;
2856
2857         if (!(hpriv->cap & HOST_CAP_SSS) || ahci_ignore_sss)
2858                 host->flags |= ATA_HOST_PARALLEL_SCAN;
2859         else
2860                 printk(KERN_INFO "ahci: SSS flag set, parallel bus scan disabled\n");
2861
2862         if (pi.flags & ATA_FLAG_EM)
2863                 ahci_reset_em(host);
2864
2865         for (i = 0; i < host->n_ports; i++) {
2866                 struct ata_port *ap = host->ports[i];
2867
2868                 ata_port_pbar_desc(ap, AHCI_PCI_BAR, -1, "abar");
2869                 ata_port_pbar_desc(ap, AHCI_PCI_BAR,
2870                                    0x100 + ap->port_no * 0x80, "port");
2871
2872                 /* set initial link pm policy */
2873                 ap->pm_policy = NOT_AVAILABLE;
2874
2875                 /* set enclosure management message type */
2876                 if (ap->flags & ATA_FLAG_EM)
2877                         ap->em_message_type = ahci_em_messages;
2878
2879
2880                 /* disabled/not-implemented port */
2881                 if (!(hpriv->port_map & (1 << i)))
2882                         ap->ops = &ata_dummy_port_ops;
2883         }
2884
2885         /* apply workaround for ASUS P5W DH Deluxe mainboard */
2886         ahci_p5wdh_workaround(host);
2887
2888         /* initialize adapter */
2889         rc = ahci_configure_dma_masks(pdev, hpriv->cap & HOST_CAP_64);
2890         if (rc)
2891                 return rc;
2892
2893         rc = ahci_reset_controller(host);
2894         if (rc)
2895                 return rc;
2896
2897         ahci_init_controller(host);
2898         ahci_print_info(host);
2899
2900         pci_set_master(pdev);
2901         return ata_host_activate(host, pdev->irq, ahci_interrupt, IRQF_SHARED,
2902                                  &ahci_sht);
2903 }
2904
2905 static int __init ahci_init(void)
2906 {
2907         return pci_register_driver(&ahci_pci_driver);
2908 }
2909
2910 static void __exit ahci_exit(void)
2911 {
2912         pci_unregister_driver(&ahci_pci_driver);
2913 }
2914
2915
2916 MODULE_AUTHOR("Jeff Garzik");
2917 MODULE_DESCRIPTION("AHCI SATA low-level driver");
2918 MODULE_LICENSE("GPL");
2919 MODULE_DEVICE_TABLE(pci, ahci_pci_tbl);
2920 MODULE_VERSION(DRV_VERSION);
2921
2922 module_init(ahci_init);
2923 module_exit(ahci_exit);