drivers/ata/sata_nv.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  sata_nv.c - NVIDIA nForce SATA
   4  *
   5  *  Copyright 2004 NVIDIA Corp.  All rights reserved.
   6  *  Copyright 2004 Andrew Chew
   7  *
   8  *  libata documentation is available via 'make {ps|pdf}docs',
   9  *  as Documentation/driver-api/libata.rst
  10  *
  11  *  No hardware documentation available outside of NVIDIA.
  12  *  This driver programs the NVIDIA SATA controller in a similar
  13  *  fashion as with other PCI IDE BMDMA controllers, with a few
  14  *  NV-specific details such as register offsets, SATA phy location,
  15  *  hotplug info, etc.
  16  *
  17  *  CK804/MCP04 controllers support an alternate programming interface
  18  *  similar to the ADMA specification (with some modifications).
  19  *  This allows the use of NCQ. Non-DMA-mapped ATA commands are still
  20  *  sent through the legacy interface.
  21  */
  22
  23 #include <linux/kernel.h>
  24 #include <linux/module.h>
  25 #include <linux/gfp.h>
  26 #include <linux/pci.h>
  27 #include <linux/blkdev.h>
  28 #include <linux/delay.h>
  29 #include <linux/interrupt.h>
  30 #include <linux/device.h>
  31 #include <scsi/scsi_host.h>
  32 #include <scsi/scsi_device.h>
  33 #include <linux/libata.h>
  34 #include <trace/events/libata.h>
  35
  36 #define DRV_NAME                        "sata_nv"
  37 #define DRV_VERSION                     "3.5"
  38
  39 #define NV_ADMA_DMA_BOUNDARY            0xffffffffUL
  40
  41 enum {
  42         NV_MMIO_BAR                     = 5,
  43
  44         NV_PORTS                        = 2,
  45         NV_PIO_MASK                     = ATA_PIO4,
  46         NV_MWDMA_MASK                   = ATA_MWDMA2,
  47         NV_UDMA_MASK                    = ATA_UDMA6,
  48         NV_PORT0_SCR_REG_OFFSET         = 0x00,
  49         NV_PORT1_SCR_REG_OFFSET         = 0x40,
  50
  51         /* INT_STATUS/ENABLE */
  52         NV_INT_STATUS                   = 0x10,
  53         NV_INT_ENABLE                   = 0x11,
  54         NV_INT_STATUS_CK804             = 0x440,
  55         NV_INT_ENABLE_CK804             = 0x441,
  56
  57         /* INT_STATUS/ENABLE bits */
  58         NV_INT_DEV                      = 0x01,
  59         NV_INT_PM                       = 0x02,
  60         NV_INT_ADDED                    = 0x04,
  61         NV_INT_REMOVED                  = 0x08,
  62
  63         NV_INT_PORT_SHIFT               = 4,    /* each port occupies 4 bits */
  64
  65         NV_INT_ALL                      = 0x0f,
  66         NV_INT_MASK                     = NV_INT_DEV |
  67                                           NV_INT_ADDED | NV_INT_REMOVED,
  68
  69         /* INT_CONFIG */
  70         NV_INT_CONFIG                   = 0x12,
  71         NV_INT_CONFIG_METHD             = 0x01, // 0 = INT, 1 = SMI
  72
  73         // For PCI config register 20
  74         NV_MCP_SATA_CFG_20              = 0x50,
  75         NV_MCP_SATA_CFG_20_SATA_SPACE_EN = 0x04,
  76         NV_MCP_SATA_CFG_20_PORT0_EN     = (1 << 17),
  77         NV_MCP_SATA_CFG_20_PORT1_EN     = (1 << 16),
  78         NV_MCP_SATA_CFG_20_PORT0_PWB_EN = (1 << 14),
  79         NV_MCP_SATA_CFG_20_PORT1_PWB_EN = (1 << 12),
  80
  81         NV_ADMA_MAX_CPBS                = 32,
  82         NV_ADMA_CPB_SZ                  = 128,
  83         NV_ADMA_APRD_SZ                 = 16,
  84         NV_ADMA_SGTBL_LEN               = (1024 - NV_ADMA_CPB_SZ) /
  85                                            NV_ADMA_APRD_SZ,
  86         NV_ADMA_SGTBL_TOTAL_LEN         = NV_ADMA_SGTBL_LEN + 5,
  87         NV_ADMA_SGTBL_SZ                = NV_ADMA_SGTBL_LEN * NV_ADMA_APRD_SZ,
  88         NV_ADMA_PORT_PRIV_DMA_SZ        = NV_ADMA_MAX_CPBS *
  89                                            (NV_ADMA_CPB_SZ + NV_ADMA_SGTBL_SZ),
  90
  91         /* BAR5 offset to ADMA general registers */
  92         NV_ADMA_GEN                     = 0x400,
  93         NV_ADMA_GEN_CTL                 = 0x00,
  94         NV_ADMA_NOTIFIER_CLEAR          = 0x30,
  95
  96         /* BAR5 offset to ADMA ports */
  97         NV_ADMA_PORT                    = 0x480,
  98
  99         /* size of ADMA port register space  */
 100         NV_ADMA_PORT_SIZE               = 0x100,
 101
 102         /* ADMA port registers */
 103         NV_ADMA_CTL                     = 0x40,
 104         NV_ADMA_CPB_COUNT               = 0x42,
 105         NV_ADMA_NEXT_CPB_IDX            = 0x43,
 106         NV_ADMA_STAT                    = 0x44,
 107         NV_ADMA_CPB_BASE_LOW            = 0x48,
 108         NV_ADMA_CPB_BASE_HIGH           = 0x4C,
 109         NV_ADMA_APPEND                  = 0x50,
 110         NV_ADMA_NOTIFIER                = 0x68,
 111         NV_ADMA_NOTIFIER_ERROR          = 0x6C,
 112
 113         /* NV_ADMA_CTL register bits */
 114         NV_ADMA_CTL_HOTPLUG_IEN         = (1 << 0),
 115         NV_ADMA_CTL_CHANNEL_RESET       = (1 << 5),
 116         NV_ADMA_CTL_GO                  = (1 << 7),
 117         NV_ADMA_CTL_AIEN                = (1 << 8),
 118         NV_ADMA_CTL_READ_NON_COHERENT   = (1 << 11),
 119         NV_ADMA_CTL_WRITE_NON_COHERENT  = (1 << 12),
 120
 121         /* CPB response flag bits */
 122         NV_CPB_RESP_DONE                = (1 << 0),
 123         NV_CPB_RESP_ATA_ERR             = (1 << 3),
 124         NV_CPB_RESP_CMD_ERR             = (1 << 4),
 125         NV_CPB_RESP_CPB_ERR             = (1 << 7),
 126
 127         /* CPB control flag bits */
 128         NV_CPB_CTL_CPB_VALID            = (1 << 0),
 129         NV_CPB_CTL_QUEUE                = (1 << 1),
 130         NV_CPB_CTL_APRD_VALID           = (1 << 2),
 131         NV_CPB_CTL_IEN                  = (1 << 3),
 132         NV_CPB_CTL_FPDMA                = (1 << 4),
 133
 134         /* APRD flags */
 135         NV_APRD_WRITE                   = (1 << 1),
 136         NV_APRD_END                     = (1 << 2),
 137         NV_APRD_CONT                    = (1 << 3),
 138
 139         /* NV_ADMA_STAT flags */
 140         NV_ADMA_STAT_TIMEOUT            = (1 << 0),
 141         NV_ADMA_STAT_HOTUNPLUG          = (1 << 1),
 142         NV_ADMA_STAT_HOTPLUG            = (1 << 2),
 143         NV_ADMA_STAT_CPBERR             = (1 << 4),
 144         NV_ADMA_STAT_SERROR             = (1 << 5),
 145         NV_ADMA_STAT_CMD_COMPLETE       = (1 << 6),
 146         NV_ADMA_STAT_IDLE               = (1 << 8),
 147         NV_ADMA_STAT_LEGACY             = (1 << 9),
 148         NV_ADMA_STAT_STOPPED            = (1 << 10),
 149         NV_ADMA_STAT_DONE               = (1 << 12),
 150         NV_ADMA_STAT_ERR                = NV_ADMA_STAT_CPBERR |
 151                                           NV_ADMA_STAT_TIMEOUT,
 152
 153         /* port flags */
 154         NV_ADMA_PORT_REGISTER_MODE      = (1 << 0),
 155         NV_ADMA_ATAPI_SETUP_COMPLETE    = (1 << 1),
 156
 157         /* MCP55 reg offset */
 158         NV_CTL_MCP55                    = 0x400,
 159         NV_INT_STATUS_MCP55             = 0x440,
 160         NV_INT_ENABLE_MCP55             = 0x444,
 161         NV_NCQ_REG_MCP55                = 0x448,
 162
 163         /* MCP55 */
 164         NV_INT_ALL_MCP55                = 0xffff,
 165         NV_INT_PORT_SHIFT_MCP55         = 16,   /* each port occupies 16 bits */
 166         NV_INT_MASK_MCP55               = NV_INT_ALL_MCP55 & 0xfffd,
 167
 168         /* SWNCQ ENABLE BITS*/
 169         NV_CTL_PRI_SWNCQ                = 0x02,
 170         NV_CTL_SEC_SWNCQ                = 0x04,
 171
 172         /* SW NCQ status bits*/
 173         NV_SWNCQ_IRQ_DEV                = (1 << 0),
 174         NV_SWNCQ_IRQ_PM                 = (1 << 1),
 175         NV_SWNCQ_IRQ_ADDED              = (1 << 2),
 176         NV_SWNCQ_IRQ_REMOVED            = (1 << 3),
 177
 178         NV_SWNCQ_IRQ_BACKOUT            = (1 << 4),
 179         NV_SWNCQ_IRQ_SDBFIS             = (1 << 5),
 180         NV_SWNCQ_IRQ_DHREGFIS           = (1 << 6),
 181         NV_SWNCQ_IRQ_DMASETUP           = (1 << 7),
 182
 183         NV_SWNCQ_IRQ_HOTPLUG            = NV_SWNCQ_IRQ_ADDED |
 184                                           NV_SWNCQ_IRQ_REMOVED,
 185
 186 };
 187
 188 /* ADMA Physical Region Descriptor - one SG segment */
 189 struct nv_adma_prd {
 190         __le64                  addr;
 191         __le32                  len;
 192         u8                      flags;
 193         u8                      packet_len;
 194         __le16                  reserved;
 195 };
 196
 197 enum nv_adma_regbits {
 198         CMDEND  = (1 << 15),            /* end of command list */
 199         WNB     = (1 << 14),            /* wait-not-BSY */
 200         IGN     = (1 << 13),            /* ignore this entry */
 201         CS1n    = (1 << (4 + 8)),       /* std. PATA signals follow... */
 202         DA2     = (1 << (2 + 8)),
 203         DA1     = (1 << (1 + 8)),
 204         DA0     = (1 << (0 + 8)),
 205 };
 206
 207 /* ADMA Command Parameter Block
 208    The first 5 SG segments are stored inside the Command Parameter Block itself.
 209    If there are more than 5 segments the remainder are stored in a separate
 210    memory area indicated by next_aprd. */
 211 struct nv_adma_cpb {
 212         u8                      resp_flags;    /* 0 */
 213         u8                      reserved1;     /* 1 */
 214         u8                      ctl_flags;     /* 2 */
 215         /* len is length of taskfile in 64 bit words */
 216         u8                      len;            /* 3  */
 217         u8                      tag;           /* 4 */
 218         u8                      next_cpb_idx;  /* 5 */
 219         __le16                  reserved2;     /* 6-7 */
 220         __le16                  tf[12];        /* 8-31 */
 221         struct nv_adma_prd      aprd[5];       /* 32-111 */
 222         __le64                  next_aprd;     /* 112-119 */
 223         __le64                  reserved3;     /* 120-127 */
 224 };
 225
 226
 227 struct nv_adma_port_priv {
 228         struct nv_adma_cpb      *cpb;
 229         dma_addr_t              cpb_dma;
 230         struct nv_adma_prd      *aprd;
 231         dma_addr_t              aprd_dma;
 232         void __iomem            *ctl_block;
 233         void __iomem            *gen_block;
 234         void __iomem            *notifier_clear_block;
 235         u64                     adma_dma_mask;
 236         u8                      flags;
 237         int                     last_issue_ncq;
 238 };
 239
 240 struct nv_host_priv {
 241         unsigned long           type;
 242 };
 243
 244 struct defer_queue {
 245         u32             defer_bits;
 246         unsigned int    head;
 247         unsigned int    tail;
 248         unsigned int    tag[ATA_MAX_QUEUE];
 249 };
 250
 251 enum ncq_saw_flag_list {
 252         ncq_saw_d2h     = (1U << 0),
 253         ncq_saw_dmas    = (1U << 1),
 254         ncq_saw_sdb     = (1U << 2),
 255         ncq_saw_backout = (1U << 3),
 256 };
 257
 258 struct nv_swncq_port_priv {
 259         struct ata_bmdma_prd *prd;       /* our SG list */
 260         dma_addr_t      prd_dma; /* and its DMA mapping */
 261         void __iomem    *sactive_block;
 262         void __iomem    *irq_block;
 263         void __iomem    *tag_block;
 264         u32             qc_active;
 265
 266         unsigned int    last_issue_tag;
 267
 268         /* fifo circular queue to store deferral command */
 269         struct defer_queue defer_queue;
 270
 271         /* for NCQ interrupt analysis */
 272         u32             dhfis_bits;
 273         u32             dmafis_bits;
 274         u32             sdbfis_bits;
 275
 276         unsigned int    ncq_flags;
 277 };
 278
 279
 280 #define NV_ADMA_CHECK_INTR(GCTL, PORT) ((GCTL) & (1 << (19 + (12 * (PORT)))))
 281
 282 static int nv_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
 283 #ifdef CONFIG_PM_SLEEP
 284 static int nv_pci_device_resume(struct pci_dev *pdev);
 285 #endif
 286 static void nv_ck804_host_stop(struct ata_host *host);
 287 static irqreturn_t nv_generic_interrupt(int irq, void *dev_instance);
 288 static irqreturn_t nv_nf2_interrupt(int irq, void *dev_instance);
 289 static irqreturn_t nv_ck804_interrupt(int irq, void *dev_instance);
 290 static int nv_scr_read(struct ata_link *link, unsigned int sc_reg, u32 *val);
 291 static int nv_scr_write(struct ata_link *link, unsigned int sc_reg, u32 val);
 292
 293 static int nv_hardreset(struct ata_link *link, unsigned int *class,
 294                         unsigned long deadline);
 295 static void nv_nf2_freeze(struct ata_port *ap);
 296 static void nv_nf2_thaw(struct ata_port *ap);
 297 static void nv_ck804_freeze(struct ata_port *ap);
 298 static void nv_ck804_thaw(struct ata_port *ap);
 299 static int nv_adma_slave_config(struct scsi_device *sdev);
 300 static int nv_adma_check_atapi_dma(struct ata_queued_cmd *qc);
 301 static enum ata_completion_errors nv_adma_qc_prep(struct ata_queued_cmd *qc);
 302 static unsigned int nv_adma_qc_issue(struct ata_queued_cmd *qc);
 303 static irqreturn_t nv_adma_interrupt(int irq, void *dev_instance);
 304 static void nv_adma_irq_clear(struct ata_port *ap);
 305 static int nv_adma_port_start(struct ata_port *ap);
 306 static void nv_adma_port_stop(struct ata_port *ap);
 307 #ifdef CONFIG_PM
 308 static int nv_adma_port_suspend(struct ata_port *ap, pm_message_t mesg);
 309 static int nv_adma_port_resume(struct ata_port *ap);
 310 #endif
 311 static void nv_adma_freeze(struct ata_port *ap);
 312 static void nv_adma_thaw(struct ata_port *ap);
 313 static void nv_adma_error_handler(struct ata_port *ap);
 314 static void nv_adma_host_stop(struct ata_host *host);
 315 static void nv_adma_post_internal_cmd(struct ata_queued_cmd *qc);
 316 static void nv_adma_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
 317
 318 static void nv_mcp55_thaw(struct ata_port *ap);
 319 static void nv_mcp55_freeze(struct ata_port *ap);
 320 static void nv_swncq_error_handler(struct ata_port *ap);
 321 static int nv_swncq_slave_config(struct scsi_device *sdev);
 322 static int nv_swncq_port_start(struct ata_port *ap);
 323 static enum ata_completion_errors nv_swncq_qc_prep(struct ata_queued_cmd *qc);
 324 static void nv_swncq_fill_sg(struct ata_queued_cmd *qc);
 325 static unsigned int nv_swncq_qc_issue(struct ata_queued_cmd *qc);
 326 static void nv_swncq_irq_clear(struct ata_port *ap, u16 fis);
 327 static irqreturn_t nv_swncq_interrupt(int irq, void *dev_instance);
 328 #ifdef CONFIG_PM
 329 static int nv_swncq_port_suspend(struct ata_port *ap, pm_message_t mesg);
 330 static int nv_swncq_port_resume(struct ata_port *ap);
 331 #endif
 332
 333 enum nv_host_type
 334 {
 335         GENERIC,
 336         NFORCE2,
 337         NFORCE3 = NFORCE2,      /* NF2 == NF3 as far as sata_nv is concerned */
 338         CK804,
 339         ADMA,
 340         MCP5x,
 341         SWNCQ,
 342 };
 343
 344 static const struct pci_device_id nv_pci_tbl[] = {
 345         { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE2S_SATA), NFORCE2 },
 346         { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE3S_SATA), NFORCE3 },
 347         { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE3S_SATA2), NFORCE3 },
 348         { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_CK804_SATA), CK804 },
 349         { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_CK804_SATA2), CK804 },
 350         { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_SATA), CK804 },
 351         { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_SATA2), CK804 },
 352         { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_SATA), MCP5x },
 353         { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_SATA2), MCP5x },
 354         { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SATA), MCP5x },
 355         { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SATA2), MCP5x },
 356         { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SATA), GENERIC },
 357         { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SATA2), GENERIC },
 358         { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SATA3), GENERIC },
 359
 360         { } /* terminate list */
 361 };
 362
 363 static struct pci_driver nv_pci_driver = {
 364         .name                   = DRV_NAME,
 365         .id_table               = nv_pci_tbl,
 366         .probe                  = nv_init_one,
 367 #ifdef CONFIG_PM_SLEEP
 368         .suspend                = ata_pci_device_suspend,
 369         .resume                 = nv_pci_device_resume,
 370 #endif
 371         .remove                 = ata_pci_remove_one,
 372 };
 373
 374 static const struct scsi_host_template nv_sht = {
 375         ATA_BMDMA_SHT(DRV_NAME),
 376 };
 377
 378 static const struct scsi_host_template nv_adma_sht = {
 379         __ATA_BASE_SHT(DRV_NAME),
 380         .can_queue              = NV_ADMA_MAX_CPBS,
 381         .sg_tablesize           = NV_ADMA_SGTBL_TOTAL_LEN,
 382         .dma_boundary           = NV_ADMA_DMA_BOUNDARY,
 383         .slave_configure        = nv_adma_slave_config,
 384         .sdev_groups            = ata_ncq_sdev_groups,
 385         .change_queue_depth     = ata_scsi_change_queue_depth,
 386         .tag_alloc_policy       = BLK_TAG_ALLOC_RR,
 387 };
 388
 389 static const struct scsi_host_template nv_swncq_sht = {
 390         __ATA_BASE_SHT(DRV_NAME),
 391         .can_queue              = ATA_MAX_QUEUE - 1,
 392         .sg_tablesize           = LIBATA_MAX_PRD,
 393         .dma_boundary           = ATA_DMA_BOUNDARY,
 394         .slave_configure        = nv_swncq_slave_config,
 395         .sdev_groups            = ata_ncq_sdev_groups,
 396         .change_queue_depth     = ata_scsi_change_queue_depth,
 397         .tag_alloc_policy       = BLK_TAG_ALLOC_RR,
 398 };
 399
 400 /*
 401  * NV SATA controllers have various different problems with hardreset
 402  * protocol depending on the specific controller and device.
 403  *
 404  * GENERIC:
 405  *
 406  *  bko11195 reports that link doesn't come online after hardreset on
 407  *  generic nv's and there have been several other similar reports on
 408  *  linux-ide.
 409  *
 410  *  bko12351#c23 reports that warmplug on MCP61 doesn't work with
 411  *  softreset.
 412  *
 413  * NF2/3:
 414  *
 415  *  bko3352 reports nf2/3 controllers can't determine device signature
 416  *  reliably after hardreset.  The following thread reports detection
 417  *  failure on cold boot with the standard debouncing timing.
 418  *
 419  *  http://thread.gmane.org/gmane.linux.ide/34098
 420  *
 421  *  bko12176 reports that hardreset fails to bring up the link during
 422  *  boot on nf2.
 423  *
 424  * CK804:
 425  *
 426  *  For initial probing after boot and hot plugging, hardreset mostly
 427  *  works fine on CK804 but curiously, reprobing on the initial port
 428  *  by rescanning or rmmod/insmod fails to acquire the initial D2H Reg
 429  *  FIS in somewhat undeterministic way.
 430  *
 431  * SWNCQ:
 432  *
 433  *  bko12351 reports that when SWNCQ is enabled, for hotplug to work,
 434  *  hardreset should be used and hardreset can't report proper
 435  *  signature, which suggests that mcp5x is closer to nf2 as long as
 436  *  reset quirkiness is concerned.
 437  *
 438  *  bko12703 reports that boot probing fails for intel SSD with
 439  *  hardreset.  Link fails to come online.  Softreset works fine.
 440  *
 441  * The failures are varied but the following patterns seem true for
 442  * all flavors.
 443  *
 444  * - Softreset during boot always works.
 445  *
 446  * - Hardreset during boot sometimes fails to bring up the link on
 447  *   certain comibnations and device signature acquisition is
 448  *   unreliable.
 449  *
 450  * - Hardreset is often necessary after hotplug.
 451  *
 452  * So, preferring softreset for boot probing and error handling (as
 453  * hardreset might bring down the link) but using hardreset for
 454  * post-boot probing should work around the above issues in most
 455  * cases.  Define nv_hardreset() which only kicks in for post-boot
 456  * probing and use it for all variants.
 457  */
 458 static struct ata_port_operations nv_generic_ops = {
 459         .inherits               = &ata_bmdma_port_ops,
 460         .lost_interrupt         = ATA_OP_NULL,
 461         .scr_read               = nv_scr_read,
 462         .scr_write              = nv_scr_write,
 463         .hardreset              = nv_hardreset,
 464 };
 465
 466 static struct ata_port_operations nv_nf2_ops = {
 467         .inherits               = &nv_generic_ops,
 468         .freeze                 = nv_nf2_freeze,
 469         .thaw                   = nv_nf2_thaw,
 470 };
 471
 472 static struct ata_port_operations nv_ck804_ops = {
 473         .inherits               = &nv_generic_ops,
 474         .freeze                 = nv_ck804_freeze,
 475         .thaw                   = nv_ck804_thaw,
 476         .host_stop              = nv_ck804_host_stop,
 477 };
 478
 479 static struct ata_port_operations nv_adma_ops = {
 480         .inherits               = &nv_ck804_ops,
 481
 482         .check_atapi_dma        = nv_adma_check_atapi_dma,
 483         .sff_tf_read            = nv_adma_tf_read,
 484         .qc_defer               = ata_std_qc_defer,
 485         .qc_prep                = nv_adma_qc_prep,
 486         .qc_issue               = nv_adma_qc_issue,
 487         .sff_irq_clear          = nv_adma_irq_clear,
 488
 489         .freeze                 = nv_adma_freeze,
 490         .thaw                   = nv_adma_thaw,
 491         .error_handler          = nv_adma_error_handler,
 492         .post_internal_cmd      = nv_adma_post_internal_cmd,
 493
 494         .port_start             = nv_adma_port_start,
 495         .port_stop              = nv_adma_port_stop,
 496 #ifdef CONFIG_PM
 497         .port_suspend           = nv_adma_port_suspend,
 498         .port_resume            = nv_adma_port_resume,
 499 #endif
 500         .host_stop              = nv_adma_host_stop,
 501 };
 502
 503 static struct ata_port_operations nv_swncq_ops = {
 504         .inherits               = &nv_generic_ops,
 505
 506         .qc_defer               = ata_std_qc_defer,
 507         .qc_prep                = nv_swncq_qc_prep,
 508         .qc_issue               = nv_swncq_qc_issue,
 509
 510         .freeze                 = nv_mcp55_freeze,
 511         .thaw                   = nv_mcp55_thaw,
 512         .error_handler          = nv_swncq_error_handler,
 513
 514 #ifdef CONFIG_PM
 515         .port_suspend           = nv_swncq_port_suspend,
 516         .port_resume            = nv_swncq_port_resume,
 517 #endif
 518         .port_start             = nv_swncq_port_start,
 519 };
 520
 521 struct nv_pi_priv {
 522         irq_handler_t                   irq_handler;
 523         const struct scsi_host_template *sht;
 524 };
 525
 526 #define NV_PI_PRIV(_irq_handler, _sht) \
 527         &(struct nv_pi_priv){ .irq_handler = _irq_handler, .sht = _sht }
 528
 529 static const struct ata_port_info nv_port_info[] = {
 530         /* generic */
 531         {
 532                 .flags          = ATA_FLAG_SATA,
 533                 .pio_mask       = NV_PIO_MASK,
 534                 .mwdma_mask     = NV_MWDMA_MASK,
 535                 .udma_mask      = NV_UDMA_MASK,
 536                 .port_ops       = &nv_generic_ops,
 537                 .private_data   = NV_PI_PRIV(nv_generic_interrupt, &nv_sht),
 538         },
 539         /* nforce2/3 */
 540         {
 541                 .flags          = ATA_FLAG_SATA,
 542                 .pio_mask       = NV_PIO_MASK,
 543                 .mwdma_mask     = NV_MWDMA_MASK,
 544                 .udma_mask      = NV_UDMA_MASK,
 545                 .port_ops       = &nv_nf2_ops,
 546                 .private_data   = NV_PI_PRIV(nv_nf2_interrupt, &nv_sht),
 547         },
 548         /* ck804 */
 549         {
 550                 .flags          = ATA_FLAG_SATA,
 551                 .pio_mask       = NV_PIO_MASK,
 552                 .mwdma_mask     = NV_MWDMA_MASK,
 553                 .udma_mask      = NV_UDMA_MASK,
 554                 .port_ops       = &nv_ck804_ops,
 555                 .private_data   = NV_PI_PRIV(nv_ck804_interrupt, &nv_sht),
 556         },
 557         /* ADMA */
 558         {
 559                 .flags          = ATA_FLAG_SATA | ATA_FLAG_NCQ,
 560                 .pio_mask       = NV_PIO_MASK,
 561                 .mwdma_mask     = NV_MWDMA_MASK,
 562                 .udma_mask      = NV_UDMA_MASK,
 563                 .port_ops       = &nv_adma_ops,
 564                 .private_data   = NV_PI_PRIV(nv_adma_interrupt, &nv_adma_sht),
 565         },
 566         /* MCP5x */
 567         {
 568                 .flags          = ATA_FLAG_SATA,
 569                 .pio_mask       = NV_PIO_MASK,
 570                 .mwdma_mask     = NV_MWDMA_MASK,
 571                 .udma_mask      = NV_UDMA_MASK,
 572                 .port_ops       = &nv_generic_ops,
 573                 .private_data   = NV_PI_PRIV(nv_generic_interrupt, &nv_sht),
 574         },
 575         /* SWNCQ */
 576         {
 577                 .flags          = ATA_FLAG_SATA | ATA_FLAG_NCQ,
 578                 .pio_mask       = NV_PIO_MASK,
 579                 .mwdma_mask     = NV_MWDMA_MASK,
 580                 .udma_mask      = NV_UDMA_MASK,
 581                 .port_ops       = &nv_swncq_ops,
 582                 .private_data   = NV_PI_PRIV(nv_swncq_interrupt, &nv_swncq_sht),
 583         },
 584 };
 585
 586 MODULE_AUTHOR("NVIDIA");
 587 MODULE_DESCRIPTION("low-level driver for NVIDIA nForce SATA controller");
 588 MODULE_LICENSE("GPL");
 589 MODULE_DEVICE_TABLE(pci, nv_pci_tbl);
 590 MODULE_VERSION(DRV_VERSION);
 591
 592 static bool adma_enabled;
 593 static bool swncq_enabled = true;
 594 static bool msi_enabled;
 595
 596 static void nv_adma_register_mode(struct ata_port *ap)
 597 {
 598         struct nv_adma_port_priv *pp = ap->private_data;
 599         void __iomem *mmio = pp->ctl_block;
 600         u16 tmp, status;
 601         int count = 0;
 602
 603         if (pp->flags & NV_ADMA_PORT_REGISTER_MODE)
 604                 return;
 605
 606         status = readw(mmio + NV_ADMA_STAT);
 607         while (!(status & NV_ADMA_STAT_IDLE) && count < 20) {
 608                 ndelay(50);
 609                 status = readw(mmio + NV_ADMA_STAT);
 610                 count++;
 611         }
 612         if (count == 20)
 613                 ata_port_warn(ap, "timeout waiting for ADMA IDLE, stat=0x%hx\n",
 614                               status);
 615
 616         tmp = readw(mmio + NV_ADMA_CTL);
 617         writew(tmp & ~NV_ADMA_CTL_GO, mmio + NV_ADMA_CTL);
 618
 619         count = 0;
 620         status = readw(mmio + NV_ADMA_STAT);
 621         while (!(status & NV_ADMA_STAT_LEGACY) && count < 20) {
 622                 ndelay(50);
 623                 status = readw(mmio + NV_ADMA_STAT);
 624                 count++;
 625         }
 626         if (count == 20)
 627                 ata_port_warn(ap,
 628                               "timeout waiting for ADMA LEGACY, stat=0x%hx\n",
 629                               status);
 630
 631         pp->flags |= NV_ADMA_PORT_REGISTER_MODE;
 632 }
 633
 634 static void nv_adma_mode(struct ata_port *ap)
 635 {
 636         struct nv_adma_port_priv *pp = ap->private_data;
 637         void __iomem *mmio = pp->ctl_block;
 638         u16 tmp, status;
 639         int count = 0;
 640
 641         if (!(pp->flags & NV_ADMA_PORT_REGISTER_MODE))
 642                 return;
 643
 644         WARN_ON(pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE);
 645
 646         tmp = readw(mmio + NV_ADMA_CTL);
 647         writew(tmp | NV_ADMA_CTL_GO, mmio + NV_ADMA_CTL);
 648
 649         status = readw(mmio + NV_ADMA_STAT);
 650         while (((status & NV_ADMA_STAT_LEGACY) ||
 651               !(status & NV_ADMA_STAT_IDLE)) && count < 20) {
 652                 ndelay(50);
 653                 status = readw(mmio + NV_ADMA_STAT);
 654                 count++;
 655         }
 656         if (count == 20)
 657                 ata_port_warn(ap,
 658                         "timeout waiting for ADMA LEGACY clear and IDLE, stat=0x%hx\n",
 659                         status);
 660
 661         pp->flags &= ~NV_ADMA_PORT_REGISTER_MODE;
 662 }
 663
 664 static int nv_adma_slave_config(struct scsi_device *sdev)
 665 {
 666         struct ata_port *ap = ata_shost_to_port(sdev->host);
 667         struct nv_adma_port_priv *pp = ap->private_data;
 668         struct nv_adma_port_priv *port0, *port1;
 669         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 670         unsigned long segment_boundary, flags;
 671         unsigned short sg_tablesize;
 672         int rc;
 673         int adma_enable;
 674         u32 current_reg, new_reg, config_mask;
 675
 676         rc = ata_scsi_slave_config(sdev);
 677
 678         if (sdev->id >= ATA_MAX_DEVICES || sdev->channel || sdev->lun)
 679                 /* Not a proper libata device, ignore */
 680                 return rc;
 681
 682         spin_lock_irqsave(ap->lock, flags);
 683
 684         if (ap->link.device[sdev->id].class == ATA_DEV_ATAPI) {
 685                 /*
 686                  * NVIDIA reports that ADMA mode does not support ATAPI commands.
 687                  * Therefore ATAPI commands are sent through the legacy interface.
 688                  * However, the legacy interface only supports 32-bit DMA.
 689                  * Restrict DMA parameters as required by the legacy interface
 690                  * when an ATAPI device is connected.
 691                  */
 692                 segment_boundary = ATA_DMA_BOUNDARY;
 693                 /* Subtract 1 since an extra entry may be needed for padding, see
 694                    libata-scsi.c */
 695                 sg_tablesize = LIBATA_MAX_PRD - 1;
 696
 697                 /* Since the legacy DMA engine is in use, we need to disable ADMA
 698                    on the port. */
 699                 adma_enable = 0;
 700                 nv_adma_register_mode(ap);
 701         } else {
 702                 segment_boundary = NV_ADMA_DMA_BOUNDARY;
 703                 sg_tablesize = NV_ADMA_SGTBL_TOTAL_LEN;
 704                 adma_enable = 1;
 705         }
 706
 707         pci_read_config_dword(pdev, NV_MCP_SATA_CFG_20, &current_reg);
 708
 709         if (ap->port_no == 1)
 710                 config_mask = NV_MCP_SATA_CFG_20_PORT1_EN |
 711                               NV_MCP_SATA_CFG_20_PORT1_PWB_EN;
 712         else
 713                 config_mask = NV_MCP_SATA_CFG_20_PORT0_EN |
 714                               NV_MCP_SATA_CFG_20_PORT0_PWB_EN;
 715
 716         if (adma_enable) {
 717                 new_reg = current_reg | config_mask;
 718                 pp->flags &= ~NV_ADMA_ATAPI_SETUP_COMPLETE;
 719         } else {
 720                 new_reg = current_reg & ~config_mask;
 721                 pp->flags |= NV_ADMA_ATAPI_SETUP_COMPLETE;
 722         }
 723
 724         if (current_reg != new_reg)
 725                 pci_write_config_dword(pdev, NV_MCP_SATA_CFG_20, new_reg);
 726
 727         port0 = ap->host->ports[0]->private_data;
 728         port1 = ap->host->ports[1]->private_data;
 729         if ((port0->flags & NV_ADMA_ATAPI_SETUP_COMPLETE) ||
 730             (port1->flags & NV_ADMA_ATAPI_SETUP_COMPLETE)) {
 731                 /*
 732                  * We have to set the DMA mask to 32-bit if either port is in
 733                  * ATAPI mode, since they are on the same PCI device which is
 734                  * used for DMA mapping.  If either SCSI device is not allocated
 735                  * yet, it's OK since that port will discover its correct
 736                  * setting when it does get allocated.
 737                  */
 738                 rc = dma_set_mask(&pdev->dev, ATA_DMA_MASK);
 739         } else {
 740                 rc = dma_set_mask(&pdev->dev, pp->adma_dma_mask);
 741         }
 742
 743         blk_queue_segment_boundary(sdev->request_queue, segment_boundary);
 744         blk_queue_max_segments(sdev->request_queue, sg_tablesize);
 745         ata_port_info(ap,
 746                       "DMA mask 0x%llX, segment boundary 0x%lX, hw segs %hu\n",
 747                       (unsigned long long)*ap->host->dev->dma_mask,
 748                       segment_boundary, sg_tablesize);
 749
 750         spin_unlock_irqrestore(ap->lock, flags);
 751
 752         return rc;
 753 }
 754
 755 static int nv_adma_check_atapi_dma(struct ata_queued_cmd *qc)
 756 {
 757         struct nv_adma_port_priv *pp = qc->ap->private_data;
 758         return !(pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE);
 759 }
 760
 761 static void nv_adma_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
 762 {
 763         /* Other than when internal or pass-through commands are executed,
 764            the only time this function will be called in ADMA mode will be
 765            if a command fails. In the failure case we don't care about going
 766            into register mode with ADMA commands pending, as the commands will
 767            all shortly be aborted anyway. We assume that NCQ commands are not
 768            issued via passthrough, which is the only way that switching into
 769            ADMA mode could abort outstanding commands. */
 770         nv_adma_register_mode(ap);
 771
 772         ata_sff_tf_read(ap, tf);
 773 }
 774
 775 static unsigned int nv_adma_tf_to_cpb(struct ata_taskfile *tf, __le16 *cpb)
 776 {
 777         unsigned int idx = 0;
 778
 779         if (tf->flags & ATA_TFLAG_ISADDR) {
 780                 if (tf->flags & ATA_TFLAG_LBA48) {
 781                         cpb[idx++] = cpu_to_le16((ATA_REG_ERR   << 8) | tf->hob_feature | WNB);
 782                         cpb[idx++] = cpu_to_le16((ATA_REG_NSECT << 8) | tf->hob_nsect);
 783                         cpb[idx++] = cpu_to_le16((ATA_REG_LBAL  << 8) | tf->hob_lbal);
 784                         cpb[idx++] = cpu_to_le16((ATA_REG_LBAM  << 8) | tf->hob_lbam);
 785                         cpb[idx++] = cpu_to_le16((ATA_REG_LBAH  << 8) | tf->hob_lbah);
 786                         cpb[idx++] = cpu_to_le16((ATA_REG_ERR    << 8) | tf->feature);
 787                 } else
 788                         cpb[idx++] = cpu_to_le16((ATA_REG_ERR    << 8) | tf->feature | WNB);
 789
 790                 cpb[idx++] = cpu_to_le16((ATA_REG_NSECT  << 8) | tf->nsect);
 791                 cpb[idx++] = cpu_to_le16((ATA_REG_LBAL   << 8) | tf->lbal);
 792                 cpb[idx++] = cpu_to_le16((ATA_REG_LBAM   << 8) | tf->lbam);
 793                 cpb[idx++] = cpu_to_le16((ATA_REG_LBAH   << 8) | tf->lbah);
 794         }
 795
 796         if (tf->flags & ATA_TFLAG_DEVICE)
 797                 cpb[idx++] = cpu_to_le16((ATA_REG_DEVICE << 8) | tf->device);
 798
 799         cpb[idx++] = cpu_to_le16((ATA_REG_CMD    << 8) | tf->command | CMDEND);
 800
 801         while (idx < 12)
 802                 cpb[idx++] = cpu_to_le16(IGN);
 803
 804         return idx;
 805 }
 806
 807 static int nv_adma_check_cpb(struct ata_port *ap, int cpb_num, int force_err)
 808 {
 809         struct nv_adma_port_priv *pp = ap->private_data;
 810         u8 flags = pp->cpb[cpb_num].resp_flags;
 811
 812         ata_port_dbg(ap, "CPB %d, flags=0x%x\n", cpb_num, flags);
 813
 814         if (unlikely((force_err ||
 815                      flags & (NV_CPB_RESP_ATA_ERR |
 816                               NV_CPB_RESP_CMD_ERR |
 817                               NV_CPB_RESP_CPB_ERR)))) {
 818                 struct ata_eh_info *ehi = &ap->link.eh_info;
 819                 int freeze = 0;
 820
 821                 ata_ehi_clear_desc(ehi);
 822                 __ata_ehi_push_desc(ehi, "CPB resp_flags 0x%x: ", flags);
 823                 if (flags & NV_CPB_RESP_ATA_ERR) {
 824                         ata_ehi_push_desc(ehi, "ATA error");
 825                         ehi->err_mask |= AC_ERR_DEV;
 826                 } else if (flags & NV_CPB_RESP_CMD_ERR) {
 827                         ata_ehi_push_desc(ehi, "CMD error");
 828                         ehi->err_mask |= AC_ERR_DEV;
 829                 } else if (flags & NV_CPB_RESP_CPB_ERR) {
 830                         ata_ehi_push_desc(ehi, "CPB error");
 831                         ehi->err_mask |= AC_ERR_SYSTEM;
 832                         freeze = 1;
 833                 } else {
 834                         /* notifier error, but no error in CPB flags? */
 835                         ata_ehi_push_desc(ehi, "unknown");
 836                         ehi->err_mask |= AC_ERR_OTHER;
 837                         freeze = 1;
 838                 }
 839                 /* Kill all commands. EH will determine what actually failed. */
 840                 if (freeze)
 841                         ata_port_freeze(ap);
 842                 else
 843                         ata_port_abort(ap);
 844                 return -1;
 845         }
 846
 847         if (likely(flags & NV_CPB_RESP_DONE))
 848                 return 1;
 849         return 0;
 850 }
 851
 852 static int nv_host_intr(struct ata_port *ap, u8 irq_stat)
 853 {
 854         struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->link.active_tag);
 855
 856         /* freeze if hotplugged */
 857         if (unlikely(irq_stat & (NV_INT_ADDED | NV_INT_REMOVED))) {
 858                 ata_port_freeze(ap);
 859                 return 1;
 860         }
 861
 862         /* bail out if not our interrupt */
 863         if (!(irq_stat & NV_INT_DEV))
 864                 return 0;
 865
 866         /* DEV interrupt w/ no active qc? */
 867         if (unlikely(!qc || (qc->tf.flags & ATA_TFLAG_POLLING))) {
 868                 ata_sff_check_status(ap);
 869                 return 1;
 870         }
 871
 872         /* handle interrupt */
 873         return ata_bmdma_port_intr(ap, qc);
 874 }
 875
 876 static irqreturn_t nv_adma_interrupt(int irq, void *dev_instance)
 877 {
 878         struct ata_host *host = dev_instance;
 879         int i, handled = 0;
 880         u32 notifier_clears[2];
 881
 882         spin_lock(&host->lock);
 883
 884         for (i = 0; i < host->n_ports; i++) {
 885                 struct ata_port *ap = host->ports[i];
 886                 struct nv_adma_port_priv *pp = ap->private_data;
 887                 void __iomem *mmio = pp->ctl_block;
 888                 u16 status;
 889                 u32 gen_ctl;
 890                 u32 notifier, notifier_error;
 891
 892                 notifier_clears[i] = 0;
 893
 894                 /* if ADMA is disabled, use standard ata interrupt handler */
 895                 if (pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE) {
 896                         u8 irq_stat = readb(host->iomap[NV_MMIO_BAR] + NV_INT_STATUS_CK804)
 897                                 >> (NV_INT_PORT_SHIFT * i);
 898                         handled += nv_host_intr(ap, irq_stat);
 899                         continue;
 900                 }
 901
 902                 /* if in ATA register mode, check for standard interrupts */
 903                 if (pp->flags & NV_ADMA_PORT_REGISTER_MODE) {
 904                         u8 irq_stat = readb(host->iomap[NV_MMIO_BAR] + NV_INT_STATUS_CK804)
 905                                 >> (NV_INT_PORT_SHIFT * i);
 906                         if (ata_tag_valid(ap->link.active_tag))
 907                                 /** NV_INT_DEV indication seems unreliable
 908                                     at times at least in ADMA mode. Force it
 909                                     on always when a command is active, to
 910                                     prevent losing interrupts. */
 911                                 irq_stat |= NV_INT_DEV;
 912                         handled += nv_host_intr(ap, irq_stat);
 913                 }
 914
 915                 notifier = readl(mmio + NV_ADMA_NOTIFIER);
 916                 notifier_error = readl(mmio + NV_ADMA_NOTIFIER_ERROR);
 917                 notifier_clears[i] = notifier | notifier_error;
 918
 919                 gen_ctl = readl(pp->gen_block + NV_ADMA_GEN_CTL);
 920
 921                 if (!NV_ADMA_CHECK_INTR(gen_ctl, ap->port_no) && !notifier &&
 922                     !notifier_error)
 923                         /* Nothing to do */
 924                         continue;
 925
 926                 status = readw(mmio + NV_ADMA_STAT);
 927
 928                 /*
 929                  * Clear status. Ensure the controller sees the
 930                  * clearing before we start looking at any of the CPB
 931                  * statuses, so that any CPB completions after this
 932                  * point in the handler will raise another interrupt.
 933                  */
 934                 writew(status, mmio + NV_ADMA_STAT);
 935                 readw(mmio + NV_ADMA_STAT); /* flush posted write */
 936                 rmb();
 937
 938                 handled++; /* irq handled if we got here */
 939
 940                 /* freeze if hotplugged or controller error */
 941                 if (unlikely(status & (NV_ADMA_STAT_HOTPLUG |
 942                                        NV_ADMA_STAT_HOTUNPLUG |
 943                                        NV_ADMA_STAT_TIMEOUT |
 944                                        NV_ADMA_STAT_SERROR))) {
 945                         struct ata_eh_info *ehi = &ap->link.eh_info;
 946
 947                         ata_ehi_clear_desc(ehi);
 948                         __ata_ehi_push_desc(ehi, "ADMA status 0x%08x: ", status);
 949                         if (status & NV_ADMA_STAT_TIMEOUT) {
 950                                 ehi->err_mask |= AC_ERR_SYSTEM;
 951                                 ata_ehi_push_desc(ehi, "timeout");
 952                         } else if (status & NV_ADMA_STAT_HOTPLUG) {
 953                                 ata_ehi_hotplugged(ehi);
 954                                 ata_ehi_push_desc(ehi, "hotplug");
 955                         } else if (status & NV_ADMA_STAT_HOTUNPLUG) {
 956                                 ata_ehi_hotplugged(ehi);
 957                                 ata_ehi_push_desc(ehi, "hot unplug");
 958                         } else if (status & NV_ADMA_STAT_SERROR) {
 959                                 /* let EH analyze SError and figure out cause */
 960                                 ata_ehi_push_desc(ehi, "SError");
 961                         } else
 962                                 ata_ehi_push_desc(ehi, "unknown");
 963                         ata_port_freeze(ap);
 964                         continue;
 965                 }
 966
 967                 if (status & (NV_ADMA_STAT_DONE |
 968                               NV_ADMA_STAT_CPBERR |
 969                               NV_ADMA_STAT_CMD_COMPLETE)) {
 970                         u32 check_commands = notifier_clears[i];
 971                         u32 done_mask = 0;
 972                         int pos, rc;
 973
 974                         if (status & NV_ADMA_STAT_CPBERR) {
 975                                 /* check all active commands */
 976                                 if (ata_tag_valid(ap->link.active_tag))
 977                                         check_commands = 1 <<
 978                                                 ap->link.active_tag;
 979                                 else
 980                                         check_commands = ap->link.sactive;
 981                         }
 982
 983                         /* check CPBs for completed commands */
 984                         while ((pos = ffs(check_commands))) {
 985                                 pos--;
 986                                 rc = nv_adma_check_cpb(ap, pos,
 987                                                 notifier_error & (1 << pos));
 988                                 if (rc > 0)
 989                                         done_mask |= 1 << pos;
 990                                 else if (unlikely(rc < 0))
 991                                         check_commands = 0;
 992                                 check_commands &= ~(1 << pos);
 993                         }
 994                         ata_qc_complete_multiple(ap, ata_qc_get_active(ap) ^ done_mask);
 995                 }
 996         }
 997
 998         if (notifier_clears[0] || notifier_clears[1]) {
 999                 /* Note: Both notifier clear registers must be written
1000                    if either is set, even if one is zero, according to NVIDIA. */
1001                 struct nv_adma_port_priv *pp = host->ports[0]->private_data;
1002                 writel(notifier_clears[0], pp->notifier_clear_block);
1003                 pp = host->ports[1]->private_data;
1004                 writel(notifier_clears[1], pp->notifier_clear_block);
1005         }
1006
1007         spin_unlock(&host->lock);
1008
1009         return IRQ_RETVAL(handled);
1010 }
1011
1012 static void nv_adma_freeze(struct ata_port *ap)
1013 {
1014         struct nv_adma_port_priv *pp = ap->private_data;
1015         void __iomem *mmio = pp->ctl_block;
1016         u16 tmp;
1017
1018         nv_ck804_freeze(ap);
1019
1020         if (pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE)
1021                 return;
1022
1023         /* clear any outstanding CK804 notifications */
1024         writeb(NV_INT_ALL << (ap->port_no * NV_INT_PORT_SHIFT),
1025                 ap->host->iomap[NV_MMIO_BAR] + NV_INT_STATUS_CK804);
1026
1027         /* Disable interrupt */
1028         tmp = readw(mmio + NV_ADMA_CTL);
1029         writew(tmp & ~(NV_ADMA_CTL_AIEN | NV_ADMA_CTL_HOTPLUG_IEN),
1030                 mmio + NV_ADMA_CTL);
1031         readw(mmio + NV_ADMA_CTL);      /* flush posted write */
1032 }
1033
1034 static void nv_adma_thaw(struct ata_port *ap)
1035 {
1036         struct nv_adma_port_priv *pp = ap->private_data;
1037         void __iomem *mmio = pp->ctl_block;
1038         u16 tmp;
1039
1040         nv_ck804_thaw(ap);
1041
1042         if (pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE)
1043                 return;
1044
1045         /* Enable interrupt */
1046         tmp = readw(mmio + NV_ADMA_CTL);
1047         writew(tmp | (NV_ADMA_CTL_AIEN | NV_ADMA_CTL_HOTPLUG_IEN),
1048                 mmio + NV_ADMA_CTL);
1049         readw(mmio + NV_ADMA_CTL);      /* flush posted write */
1050 }
1051
1052 static void nv_adma_irq_clear(struct ata_port *ap)
1053 {
1054         struct nv_adma_port_priv *pp = ap->private_data;
1055         void __iomem *mmio = pp->ctl_block;
1056         u32 notifier_clears[2];
1057
1058         if (pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE) {
1059                 ata_bmdma_irq_clear(ap);
1060                 return;
1061         }
1062
1063         /* clear any outstanding CK804 notifications */
1064         writeb(NV_INT_ALL << (ap->port_no * NV_INT_PORT_SHIFT),
1065                 ap->host->iomap[NV_MMIO_BAR] + NV_INT_STATUS_CK804);
1066
1067         /* clear ADMA status */
1068         writew(0xffff, mmio + NV_ADMA_STAT);
1069
1070         /* clear notifiers - note both ports need to be written with
1071            something even though we are only clearing on one */
1072         if (ap->port_no == 0) {
1073                 notifier_clears[0] = 0xFFFFFFFF;
1074                 notifier_clears[1] = 0;
1075         } else {
1076                 notifier_clears[0] = 0;
1077                 notifier_clears[1] = 0xFFFFFFFF;
1078         }
1079         pp = ap->host->ports[0]->private_data;
1080         writel(notifier_clears[0], pp->notifier_clear_block);
1081         pp = ap->host->ports[1]->private_data;
1082         writel(notifier_clears[1], pp->notifier_clear_block);
1083 }
1084
1085 static void nv_adma_post_internal_cmd(struct ata_queued_cmd *qc)
1086 {
1087         struct nv_adma_port_priv *pp = qc->ap->private_data;
1088
1089         if (pp->flags & NV_ADMA_PORT_REGISTER_MODE)
1090                 ata_bmdma_post_internal_cmd(qc);
1091 }
1092
1093 static int nv_adma_port_start(struct ata_port *ap)
1094 {
1095         struct device *dev = ap->host->dev;
1096         struct nv_adma_port_priv *pp;
1097         int rc;
1098         void *mem;
1099         dma_addr_t mem_dma;
1100         void __iomem *mmio;
1101         struct pci_dev *pdev = to_pci_dev(dev);
1102         u16 tmp;
1103
1104         /*
1105          * Ensure DMA mask is set to 32-bit before allocating legacy PRD and
1106          * pad buffers.
1107          */
1108         rc = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
1109         if (rc)
1110                 return rc;
1111
1112         /* we might fallback to bmdma, allocate bmdma resources */
1113         rc = ata_bmdma_port_start(ap);
1114         if (rc)
1115                 return rc;
1116
1117         pp = devm_kzalloc(dev, sizeof(*pp), GFP_KERNEL);
1118         if (!pp)
1119                 return -ENOMEM;
1120
1121         mmio = ap->host->iomap[NV_MMIO_BAR] + NV_ADMA_PORT +
1122                ap->port_no * NV_ADMA_PORT_SIZE;
1123         pp->ctl_block = mmio;
1124         pp->gen_block = ap->host->iomap[NV_MMIO_BAR] + NV_ADMA_GEN;
1125         pp->notifier_clear_block = pp->gen_block +
1126                NV_ADMA_NOTIFIER_CLEAR + (4 * ap->port_no);
1127
1128         /*
1129          * Now that the legacy PRD and padding buffer are allocated we can
1130          * raise the DMA mask to allocate the CPB/APRD table.
1131          */
1132         dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
1133
1134         pp->adma_dma_mask = *dev->dma_mask;
1135
1136         mem = dmam_alloc_coherent(dev, NV_ADMA_PORT_PRIV_DMA_SZ,
1137                                   &mem_dma, GFP_KERNEL);
1138         if (!mem)
1139                 return -ENOMEM;
1140
1141         /*
1142          * First item in chunk of DMA memory:
1143          * 128-byte command parameter block (CPB)
1144          * one for each command tag
1145          */
1146         pp->cpb     = mem;
1147         pp->cpb_dma = mem_dma;
1148
1149         writel(mem_dma & 0xFFFFFFFF,    mmio + NV_ADMA_CPB_BASE_LOW);
1150         writel((mem_dma >> 16) >> 16,   mmio + NV_ADMA_CPB_BASE_HIGH);
1151
1152         mem     += NV_ADMA_MAX_CPBS * NV_ADMA_CPB_SZ;
1153         mem_dma += NV_ADMA_MAX_CPBS * NV_ADMA_CPB_SZ;
1154
1155         /*
1156          * Second item: block of ADMA_SGTBL_LEN s/g entries
1157          */
1158         pp->aprd = mem;
1159         pp->aprd_dma = mem_dma;
1160
1161         ap->private_data = pp;
1162
1163         /* clear any outstanding interrupt conditions */
1164         writew(0xffff, mmio + NV_ADMA_STAT);
1165
1166         /* initialize port variables */
1167         pp->flags = NV_ADMA_PORT_REGISTER_MODE;
1168
1169         /* clear CPB fetch count */
1170         writew(0, mmio + NV_ADMA_CPB_COUNT);
1171
1172         /* clear GO for register mode, enable interrupt */
1173         tmp = readw(mmio + NV_ADMA_CTL);
1174         writew((tmp & ~NV_ADMA_CTL_GO) | NV_ADMA_CTL_AIEN |
1175                 NV_ADMA_CTL_HOTPLUG_IEN, mmio + NV_ADMA_CTL);
1176
1177         tmp = readw(mmio + NV_ADMA_CTL);
1178         writew(tmp | NV_ADMA_CTL_CHANNEL_RESET, mmio + NV_ADMA_CTL);
1179         readw(mmio + NV_ADMA_CTL);      /* flush posted write */
1180         udelay(1);
1181         writew(tmp & ~NV_ADMA_CTL_CHANNEL_RESET, mmio + NV_ADMA_CTL);
1182         readw(mmio + NV_ADMA_CTL);      /* flush posted write */
1183
1184         return 0;
1185 }
1186
1187 static void nv_adma_port_stop(struct ata_port *ap)
1188 {
1189         struct nv_adma_port_priv *pp = ap->private_data;
1190         void __iomem *mmio = pp->ctl_block;
1191
1192         writew(0, mmio + NV_ADMA_CTL);
1193 }
1194
1195 #ifdef CONFIG_PM
1196 static int nv_adma_port_suspend(struct ata_port *ap, pm_message_t mesg)
1197 {
1198         struct nv_adma_port_priv *pp = ap->private_data;
1199         void __iomem *mmio = pp->ctl_block;
1200
1201         /* Go to register mode - clears GO */
1202         nv_adma_register_mode(ap);
1203
1204         /* clear CPB fetch count */
1205         writew(0, mmio + NV_ADMA_CPB_COUNT);
1206
1207         /* disable interrupt, shut down port */
1208         writew(0, mmio + NV_ADMA_CTL);
1209
1210         return 0;
1211 }
1212
1213 static int nv_adma_port_resume(struct ata_port *ap)
1214 {
1215         struct nv_adma_port_priv *pp = ap->private_data;
1216         void __iomem *mmio = pp->ctl_block;
1217         u16 tmp;
1218
1219         /* set CPB block location */
1220         writel(pp->cpb_dma & 0xFFFFFFFF,        mmio + NV_ADMA_CPB_BASE_LOW);
1221         writel((pp->cpb_dma >> 16) >> 16,       mmio + NV_ADMA_CPB_BASE_HIGH);
1222
1223         /* clear any outstanding interrupt conditions */
1224         writew(0xffff, mmio + NV_ADMA_STAT);
1225
1226         /* initialize port variables */
1227         pp->flags |= NV_ADMA_PORT_REGISTER_MODE;
1228
1229         /* clear CPB fetch count */
1230         writew(0, mmio + NV_ADMA_CPB_COUNT);
1231
1232         /* clear GO for register mode, enable interrupt */
1233         tmp = readw(mmio + NV_ADMA_CTL);
1234         writew((tmp & ~NV_ADMA_CTL_GO) | NV_ADMA_CTL_AIEN |
1235                 NV_ADMA_CTL_HOTPLUG_IEN, mmio + NV_ADMA_CTL);
1236
1237         tmp = readw(mmio + NV_ADMA_CTL);
1238         writew(tmp | NV_ADMA_CTL_CHANNEL_RESET, mmio + NV_ADMA_CTL);
1239         readw(mmio + NV_ADMA_CTL);      /* flush posted write */
1240         udelay(1);
1241         writew(tmp & ~NV_ADMA_CTL_CHANNEL_RESET, mmio + NV_ADMA_CTL);
1242         readw(mmio + NV_ADMA_CTL);      /* flush posted write */
1243
1244         return 0;
1245 }
1246 #endif
1247
1248 static void nv_adma_setup_port(struct ata_port *ap)
1249 {
1250         void __iomem *mmio = ap->host->iomap[NV_MMIO_BAR];
1251         struct ata_ioports *ioport = &ap->ioaddr;
1252
1253         mmio += NV_ADMA_PORT + ap->port_no * NV_ADMA_PORT_SIZE;
1254
1255         ioport->cmd_addr        = mmio;
1256         ioport->data_addr       = mmio + (ATA_REG_DATA * 4);
1257         ioport->error_addr      =
1258         ioport->feature_addr    = mmio + (ATA_REG_ERR * 4);
1259         ioport->nsect_addr      = mmio + (ATA_REG_NSECT * 4);
1260         ioport->lbal_addr       = mmio + (ATA_REG_LBAL * 4);
1261         ioport->lbam_addr       = mmio + (ATA_REG_LBAM * 4);
1262         ioport->lbah_addr       = mmio + (ATA_REG_LBAH * 4);
1263         ioport->device_addr     = mmio + (ATA_REG_DEVICE * 4);
1264         ioport->status_addr     =
1265         ioport->command_addr    = mmio + (ATA_REG_STATUS * 4);
1266         ioport->altstatus_addr  =
1267         ioport->ctl_addr        = mmio + 0x20;
1268 }
1269
1270 static int nv_adma_host_init(struct ata_host *host)
1271 {
1272         struct pci_dev *pdev = to_pci_dev(host->dev);
1273         unsigned int i;
1274         u32 tmp32;
1275
1276         /* enable ADMA on the ports */
1277         pci_read_config_dword(pdev, NV_MCP_SATA_CFG_20, &tmp32);
1278         tmp32 |= NV_MCP_SATA_CFG_20_PORT0_EN |
1279                  NV_MCP_SATA_CFG_20_PORT0_PWB_EN |
1280                  NV_MCP_SATA_CFG_20_PORT1_EN |
1281                  NV_MCP_SATA_CFG_20_PORT1_PWB_EN;
1282
1283         pci_write_config_dword(pdev, NV_MCP_SATA_CFG_20, tmp32);
1284
1285         for (i = 0; i < host->n_ports; i++)
1286                 nv_adma_setup_port(host->ports[i]);
1287
1288         return 0;
1289 }
1290
1291 static void nv_adma_fill_aprd(struct ata_queued_cmd *qc,
1292                               struct scatterlist *sg,
1293                               int idx,
1294                               struct nv_adma_prd *aprd)
1295 {
1296         u8 flags = 0;
1297         if (qc->tf.flags & ATA_TFLAG_WRITE)
1298                 flags |= NV_APRD_WRITE;
1299         if (idx == qc->n_elem - 1)
1300                 flags |= NV_APRD_END;
1301         else if (idx != 4)
1302                 flags |= NV_APRD_CONT;
1303
1304         aprd->addr  = cpu_to_le64(((u64)sg_dma_address(sg)));
1305         aprd->len   = cpu_to_le32(((u32)sg_dma_len(sg))); /* len in bytes */
1306         aprd->flags = flags;
1307         aprd->packet_len = 0;
1308 }
1309
1310 static void nv_adma_fill_sg(struct ata_queued_cmd *qc, struct nv_adma_cpb *cpb)
1311 {
1312         struct nv_adma_port_priv *pp = qc->ap->private_data;
1313         struct nv_adma_prd *aprd;
1314         struct scatterlist *sg;
1315         unsigned int si;
1316
1317         for_each_sg(qc->sg, sg, qc->n_elem, si) {
1318                 aprd = (si < 5) ? &cpb->aprd[si] :
1319                         &pp->aprd[NV_ADMA_SGTBL_LEN * qc->hw_tag + (si-5)];
1320                 nv_adma_fill_aprd(qc, sg, si, aprd);
1321         }
1322         if (si > 5)
1323                 cpb->next_aprd = cpu_to_le64(((u64)(pp->aprd_dma + NV_ADMA_SGTBL_SZ * qc->hw_tag)));
1324         else
1325                 cpb->next_aprd = cpu_to_le64(0);
1326 }
1327
1328 static int nv_adma_use_reg_mode(struct ata_queued_cmd *qc)
1329 {
1330         struct nv_adma_port_priv *pp = qc->ap->private_data;
1331
1332         /* ADMA engine can only be used for non-ATAPI DMA commands,
1333            or interrupt-driven no-data commands. */
1334         if ((pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE) ||
1335            (qc->tf.flags & ATA_TFLAG_POLLING))
1336                 return 1;
1337
1338         if ((qc->flags & ATA_QCFLAG_DMAMAP) ||
1339            (qc->tf.protocol == ATA_PROT_NODATA))
1340                 return 0;
1341
1342         return 1;
1343 }
1344
1345 static enum ata_completion_errors nv_adma_qc_prep(struct ata_queued_cmd *qc)
1346 {
1347         struct nv_adma_port_priv *pp = qc->ap->private_data;
1348         struct nv_adma_cpb *cpb = &pp->cpb[qc->hw_tag];
1349         u8 ctl_flags = NV_CPB_CTL_CPB_VALID |
1350                        NV_CPB_CTL_IEN;
1351
1352         if (nv_adma_use_reg_mode(qc)) {
1353                 BUG_ON(!(pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE) &&
1354                         (qc->flags & ATA_QCFLAG_DMAMAP));
1355                 nv_adma_register_mode(qc->ap);
1356                 ata_bmdma_qc_prep(qc);
1357                 return AC_ERR_OK;
1358         }
1359
1360         cpb->resp_flags = NV_CPB_RESP_DONE;
1361         wmb();
1362         cpb->ctl_flags = 0;
1363         wmb();
1364
1365         cpb->len                = 3;
1366         cpb->tag                = qc->hw_tag;
1367         cpb->next_cpb_idx       = 0;
1368
1369         /* turn on NCQ flags for NCQ commands */
1370         if (qc->tf.protocol == ATA_PROT_NCQ)
1371                 ctl_flags |= NV_CPB_CTL_QUEUE | NV_CPB_CTL_FPDMA;
1372
1373         nv_adma_tf_to_cpb(&qc->tf, cpb->tf);
1374
1375         if (qc->flags & ATA_QCFLAG_DMAMAP) {
1376                 nv_adma_fill_sg(qc, cpb);
1377                 ctl_flags |= NV_CPB_CTL_APRD_VALID;
1378         } else
1379                 memset(&cpb->aprd[0], 0, sizeof(struct nv_adma_prd) * 5);
1380
1381         /* Be paranoid and don't let the device see NV_CPB_CTL_CPB_VALID
1382            until we are finished filling in all of the contents */
1383         wmb();
1384         cpb->ctl_flags = ctl_flags;
1385         wmb();
1386         cpb->resp_flags = 0;
1387
1388         return AC_ERR_OK;
1389 }
1390
1391 static unsigned int nv_adma_qc_issue(struct ata_queued_cmd *qc)
1392 {
1393         struct nv_adma_port_priv *pp = qc->ap->private_data;
1394         void __iomem *mmio = pp->ctl_block;
1395         int curr_ncq = (qc->tf.protocol == ATA_PROT_NCQ);
1396
1397         /* We can't handle result taskfile with NCQ commands, since
1398            retrieving the taskfile switches us out of ADMA mode and would abort
1399            existing commands. */
1400         if (unlikely(qc->tf.protocol == ATA_PROT_NCQ &&
1401                      (qc->flags & ATA_QCFLAG_RESULT_TF))) {
1402                 ata_dev_err(qc->dev, "NCQ w/ RESULT_TF not allowed\n");
1403                 return AC_ERR_SYSTEM;
1404         }
1405
1406         if (nv_adma_use_reg_mode(qc)) {
1407                 /* use ATA register mode */
1408                 BUG_ON(!(pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE) &&
1409                         (qc->flags & ATA_QCFLAG_DMAMAP));
1410                 nv_adma_register_mode(qc->ap);
1411                 return ata_bmdma_qc_issue(qc);
1412         } else
1413                 nv_adma_mode(qc->ap);
1414
1415         /* write append register, command tag in lower 8 bits
1416            and (number of cpbs to append -1) in top 8 bits */
1417         wmb();
1418
1419         if (curr_ncq != pp->last_issue_ncq) {
1420                 /* Seems to need some delay before switching between NCQ and
1421                    non-NCQ commands, else we get command timeouts and such. */
1422                 udelay(20);
1423                 pp->last_issue_ncq = curr_ncq;
1424         }
1425
1426         writew(qc->hw_tag, mmio + NV_ADMA_APPEND);
1427
1428         return 0;
1429 }
1430
1431 static irqreturn_t nv_generic_interrupt(int irq, void *dev_instance)
1432 {
1433         struct ata_host *host = dev_instance;
1434         unsigned int i;
1435         unsigned int handled = 0;
1436         unsigned long flags;
1437
1438         spin_lock_irqsave(&host->lock, flags);
1439
1440         for (i = 0; i < host->n_ports; i++) {
1441                 struct ata_port *ap = host->ports[i];
1442                 struct ata_queued_cmd *qc;
1443
1444                 qc = ata_qc_from_tag(ap, ap->link.active_tag);
1445                 if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING))) {
1446                         handled += ata_bmdma_port_intr(ap, qc);
1447                 } else {
1448                         /*
1449                          * No request pending?  Clear interrupt status
1450                          * anyway, in case there's one pending.
1451                          */
1452                         ap->ops->sff_check_status(ap);
1453                 }
1454         }
1455
1456         spin_unlock_irqrestore(&host->lock, flags);
1457
1458         return IRQ_RETVAL(handled);
1459 }
1460
1461 static irqreturn_t nv_do_interrupt(struct ata_host *host, u8 irq_stat)
1462 {
1463         int i, handled = 0;
1464
1465         for (i = 0; i < host->n_ports; i++) {
1466                 handled += nv_host_intr(host->ports[i], irq_stat);
1467                 irq_stat >>= NV_INT_PORT_SHIFT;
1468         }
1469
1470         return IRQ_RETVAL(handled);
1471 }
1472
1473 static irqreturn_t nv_nf2_interrupt(int irq, void *dev_instance)
1474 {
1475         struct ata_host *host = dev_instance;
1476         u8 irq_stat;
1477         irqreturn_t ret;
1478
1479         spin_lock(&host->lock);
1480         irq_stat = ioread8(host->ports[0]->ioaddr.scr_addr + NV_INT_STATUS);
1481         ret = nv_do_interrupt(host, irq_stat);
1482         spin_unlock(&host->lock);
1483
1484         return ret;
1485 }
1486
1487 static irqreturn_t nv_ck804_interrupt(int irq, void *dev_instance)
1488 {
1489         struct ata_host *host = dev_instance;
1490         u8 irq_stat;
1491         irqreturn_t ret;
1492
1493         spin_lock(&host->lock);
1494         irq_stat = readb(host->iomap[NV_MMIO_BAR] + NV_INT_STATUS_CK804);
1495         ret = nv_do_interrupt(host, irq_stat);
1496         spin_unlock(&host->lock);
1497
1498         return ret;
1499 }
1500
1501 static int nv_scr_read(struct ata_link *link, unsigned int sc_reg, u32 *val)
1502 {
1503         if (sc_reg > SCR_CONTROL)
1504                 return -EINVAL;
1505
1506         *val = ioread32(link->ap->ioaddr.scr_addr + (sc_reg * 4));
1507         return 0;
1508 }
1509
1510 static int nv_scr_write(struct ata_link *link, unsigned int sc_reg, u32 val)
1511 {
1512         if (sc_reg > SCR_CONTROL)
1513                 return -EINVAL;
1514
1515         iowrite32(val, link->ap->ioaddr.scr_addr + (sc_reg * 4));
1516         return 0;
1517 }
1518
1519 static int nv_hardreset(struct ata_link *link, unsigned int *class,
1520                         unsigned long deadline)
1521 {
1522         struct ata_eh_context *ehc = &link->eh_context;
1523
1524         /* Do hardreset iff it's post-boot probing, please read the
1525          * comment above port ops for details.
1526          */
1527         if (!(link->ap->pflags & ATA_PFLAG_LOADING) &&
1528             !ata_dev_enabled(link->device))
1529                 sata_link_hardreset(link, sata_deb_timing_hotplug, deadline,
1530                                     NULL, NULL);
1531         else {
1532                 const unsigned int *timing = sata_ehc_deb_timing(ehc);
1533                 int rc;
1534
1535                 if (!(ehc->i.flags & ATA_EHI_QUIET))
1536                         ata_link_info(link,
1537                                       "nv: skipping hardreset on occupied port\n");
1538
1539                 /* make sure the link is online */
1540                 rc = sata_link_resume(link, timing, deadline);
1541                 /* whine about phy resume failure but proceed */
1542                 if (rc && rc != -EOPNOTSUPP)
1543                         ata_link_warn(link, "failed to resume link (errno=%d)\n",
1544                                       rc);
1545         }
1546
1547         /* device signature acquisition is unreliable */
1548         return -EAGAIN;
1549 }
1550
1551 static void nv_nf2_freeze(struct ata_port *ap)
1552 {
1553         void __iomem *scr_addr = ap->host->ports[0]->ioaddr.scr_addr;
1554         int shift = ap->port_no * NV_INT_PORT_SHIFT;
1555         u8 mask;
1556
1557         mask = ioread8(scr_addr + NV_INT_ENABLE);
1558         mask &= ~(NV_INT_ALL << shift);
1559         iowrite8(mask, scr_addr + NV_INT_ENABLE);
1560 }
1561
1562 static void nv_nf2_thaw(struct ata_port *ap)
1563 {
1564         void __iomem *scr_addr = ap->host->ports[0]->ioaddr.scr_addr;
1565         int shift = ap->port_no * NV_INT_PORT_SHIFT;
1566         u8 mask;
1567
1568         iowrite8(NV_INT_ALL << shift, scr_addr + NV_INT_STATUS);
1569
1570         mask = ioread8(scr_addr + NV_INT_ENABLE);
1571         mask |= (NV_INT_MASK << shift);
1572         iowrite8(mask, scr_addr + NV_INT_ENABLE);
1573 }
1574
1575 static void nv_ck804_freeze(struct ata_port *ap)
1576 {
1577         void __iomem *mmio_base = ap->host->iomap[NV_MMIO_BAR];
1578         int shift = ap->port_no * NV_INT_PORT_SHIFT;
1579         u8 mask;
1580
1581         mask = readb(mmio_base + NV_INT_ENABLE_CK804);
1582         mask &= ~(NV_INT_ALL << shift);
1583         writeb(mask, mmio_base + NV_INT_ENABLE_CK804);
1584 }
1585
1586 static void nv_ck804_thaw(struct ata_port *ap)
1587 {
1588         void __iomem *mmio_base = ap->host->iomap[NV_MMIO_BAR];
1589         int shift = ap->port_no * NV_INT_PORT_SHIFT;
1590         u8 mask;
1591
1592         writeb(NV_INT_ALL << shift, mmio_base + NV_INT_STATUS_CK804);
1593
1594         mask = readb(mmio_base + NV_INT_ENABLE_CK804);
1595         mask |= (NV_INT_MASK << shift);
1596         writeb(mask, mmio_base + NV_INT_ENABLE_CK804);
1597 }
1598
1599 static void nv_mcp55_freeze(struct ata_port *ap)
1600 {
1601         void __iomem *mmio_base = ap->host->iomap[NV_MMIO_BAR];
1602         int shift = ap->port_no * NV_INT_PORT_SHIFT_MCP55;
1603         u32 mask;
1604
1605         writel(NV_INT_ALL_MCP55 << shift, mmio_base + NV_INT_STATUS_MCP55);
1606
1607         mask = readl(mmio_base + NV_INT_ENABLE_MCP55);
1608         mask &= ~(NV_INT_ALL_MCP55 << shift);
1609         writel(mask, mmio_base + NV_INT_ENABLE_MCP55);
1610 }
1611
1612 static void nv_mcp55_thaw(struct ata_port *ap)
1613 {
1614         void __iomem *mmio_base = ap->host->iomap[NV_MMIO_BAR];
1615         int shift = ap->port_no * NV_INT_PORT_SHIFT_MCP55;
1616         u32 mask;
1617
1618         writel(NV_INT_ALL_MCP55 << shift, mmio_base + NV_INT_STATUS_MCP55);
1619
1620         mask = readl(mmio_base + NV_INT_ENABLE_MCP55);
1621         mask |= (NV_INT_MASK_MCP55 << shift);
1622         writel(mask, mmio_base + NV_INT_ENABLE_MCP55);
1623 }
1624
1625 static void nv_adma_error_handler(struct ata_port *ap)
1626 {
1627         struct nv_adma_port_priv *pp = ap->private_data;
1628         if (!(pp->flags & NV_ADMA_PORT_REGISTER_MODE)) {
1629                 void __iomem *mmio = pp->ctl_block;
1630                 int i;
1631                 u16 tmp;
1632
1633                 if (ata_tag_valid(ap->link.active_tag) || ap->link.sactive) {
1634                         u32 notifier = readl(mmio + NV_ADMA_NOTIFIER);
1635                         u32 notifier_error = readl(mmio + NV_ADMA_NOTIFIER_ERROR);
1636                         u32 gen_ctl = readl(pp->gen_block + NV_ADMA_GEN_CTL);
1637                         u32 status = readw(mmio + NV_ADMA_STAT);
1638                         u8 cpb_count = readb(mmio + NV_ADMA_CPB_COUNT);
1639                         u8 next_cpb_idx = readb(mmio + NV_ADMA_NEXT_CPB_IDX);
1640
1641                         ata_port_err(ap,
1642                                 "EH in ADMA mode, notifier 0x%X "
1643                                 "notifier_error 0x%X gen_ctl 0x%X status 0x%X "
1644                                 "next cpb count 0x%X next cpb idx 0x%x\n",
1645                                 notifier, notifier_error, gen_ctl, status,
1646                                 cpb_count, next_cpb_idx);
1647
1648                         for (i = 0; i < NV_ADMA_MAX_CPBS; i++) {
1649                                 struct nv_adma_cpb *cpb = &pp->cpb[i];
1650                                 if ((ata_tag_valid(ap->link.active_tag) && i == ap->link.active_tag) ||
1651                                     ap->link.sactive & (1 << i))
1652                                         ata_port_err(ap,
1653                                                 "CPB %d: ctl_flags 0x%x, resp_flags 0x%x\n",
1654                                                 i, cpb->ctl_flags, cpb->resp_flags);
1655                         }
1656                 }
1657
1658                 /* Push us back into port register mode for error handling. */
1659                 nv_adma_register_mode(ap);
1660
1661                 /* Mark all of the CPBs as invalid to prevent them from
1662                    being executed */
1663                 for (i = 0; i < NV_ADMA_MAX_CPBS; i++)
1664                         pp->cpb[i].ctl_flags &= ~NV_CPB_CTL_CPB_VALID;
1665
1666                 /* clear CPB fetch count */
1667                 writew(0, mmio + NV_ADMA_CPB_COUNT);
1668
1669                 /* Reset channel */
1670                 tmp = readw(mmio + NV_ADMA_CTL);
1671                 writew(tmp | NV_ADMA_CTL_CHANNEL_RESET, mmio + NV_ADMA_CTL);
1672                 readw(mmio + NV_ADMA_CTL);      /* flush posted write */
1673                 udelay(1);
1674                 writew(tmp & ~NV_ADMA_CTL_CHANNEL_RESET, mmio + NV_ADMA_CTL);
1675                 readw(mmio + NV_ADMA_CTL);      /* flush posted write */
1676         }
1677
1678         ata_bmdma_error_handler(ap);
1679 }
1680
1681 static void nv_swncq_qc_to_dq(struct ata_port *ap, struct ata_queued_cmd *qc)
1682 {
1683         struct nv_swncq_port_priv *pp = ap->private_data;
1684         struct defer_queue *dq = &pp->defer_queue;
1685
1686         /* queue is full */
1687         WARN_ON(dq->tail - dq->head == ATA_MAX_QUEUE);
1688         dq->defer_bits |= (1 << qc->hw_tag);
1689         dq->tag[dq->tail++ & (ATA_MAX_QUEUE - 1)] = qc->hw_tag;
1690 }
1691
1692 static struct ata_queued_cmd *nv_swncq_qc_from_dq(struct ata_port *ap)
1693 {
1694         struct nv_swncq_port_priv *pp = ap->private_data;
1695         struct defer_queue *dq = &pp->defer_queue;
1696         unsigned int tag;
1697
1698         if (dq->head == dq->tail)       /* null queue */
1699                 return NULL;
1700
1701         tag = dq->tag[dq->head & (ATA_MAX_QUEUE - 1)];
1702         dq->tag[dq->head++ & (ATA_MAX_QUEUE - 1)] = ATA_TAG_POISON;
1703         WARN_ON(!(dq->defer_bits & (1 << tag)));
1704         dq->defer_bits &= ~(1 << tag);
1705
1706         return ata_qc_from_tag(ap, tag);
1707 }
1708
1709 static void nv_swncq_fis_reinit(struct ata_port *ap)
1710 {
1711         struct nv_swncq_port_priv *pp = ap->private_data;
1712
1713         pp->dhfis_bits = 0;
1714         pp->dmafis_bits = 0;
1715         pp->sdbfis_bits = 0;
1716         pp->ncq_flags = 0;
1717 }
1718
1719 static void nv_swncq_pp_reinit(struct ata_port *ap)
1720 {
1721         struct nv_swncq_port_priv *pp = ap->private_data;
1722         struct defer_queue *dq = &pp->defer_queue;
1723
1724         dq->head = 0;
1725         dq->tail = 0;
1726         dq->defer_bits = 0;
1727         pp->qc_active = 0;
1728         pp->last_issue_tag = ATA_TAG_POISON;
1729         nv_swncq_fis_reinit(ap);
1730 }
1731
1732 static void nv_swncq_irq_clear(struct ata_port *ap, u16 fis)
1733 {
1734         struct nv_swncq_port_priv *pp = ap->private_data;
1735
1736         writew(fis, pp->irq_block);
1737 }
1738
1739 static void __ata_bmdma_stop(struct ata_port *ap)
1740 {
1741         struct ata_queued_cmd qc;
1742
1743         qc.ap = ap;
1744         ata_bmdma_stop(&qc);
1745 }
1746
1747 static void nv_swncq_ncq_stop(struct ata_port *ap)
1748 {
1749         struct nv_swncq_port_priv *pp = ap->private_data;
1750         unsigned int i;
1751         u32 sactive;
1752         u32 done_mask;
1753
1754         ata_port_err(ap, "EH in SWNCQ mode,QC:qc_active 0x%llX sactive 0x%X\n",
1755                      ap->qc_active, ap->link.sactive);
1756         ata_port_err(ap,
1757                 "SWNCQ:qc_active 0x%X defer_bits 0x%X last_issue_tag 0x%x\n  "
1758                 "dhfis 0x%X dmafis 0x%X sdbfis 0x%X\n",
1759                 pp->qc_active, pp->defer_queue.defer_bits, pp->last_issue_tag,
1760                 pp->dhfis_bits, pp->dmafis_bits, pp->sdbfis_bits);
1761
1762         ata_port_err(ap, "ATA_REG 0x%X ERR_REG 0x%X\n",
1763                      ap->ops->sff_check_status(ap),
1764                      ioread8(ap->ioaddr.error_addr));
1765
1766         sactive = readl(pp->sactive_block);
1767         done_mask = pp->qc_active ^ sactive;
1768
1769         ata_port_err(ap, "tag : dhfis dmafis sdbfis sactive\n");
1770         for (i = 0; i < ATA_MAX_QUEUE; i++) {
1771                 u8 err = 0;
1772                 if (pp->qc_active & (1 << i))
1773                         err = 0;
1774                 else if (done_mask & (1 << i))
1775                         err = 1;
1776                 else
1777                         continue;
1778
1779                 ata_port_err(ap,
1780                              "tag 0x%x: %01x %01x %01x %01x %s\n", i,
1781                              (pp->dhfis_bits >> i) & 0x1,
1782                              (pp->dmafis_bits >> i) & 0x1,
1783                              (pp->sdbfis_bits >> i) & 0x1,
1784                              (sactive >> i) & 0x1,
1785                              (err ? "error! tag doesn't exit" : " "));
1786         }
1787
1788         nv_swncq_pp_reinit(ap);
1789         ap->ops->sff_irq_clear(ap);
1790         __ata_bmdma_stop(ap);
1791         nv_swncq_irq_clear(ap, 0xffff);
1792 }
1793
1794 static void nv_swncq_error_handler(struct ata_port *ap)
1795 {
1796         struct ata_eh_context *ehc = &ap->link.eh_context;
1797
1798         if (ap->link.sactive) {
1799                 nv_swncq_ncq_stop(ap);
1800                 ehc->i.action |= ATA_EH_RESET;
1801         }
1802
1803         ata_bmdma_error_handler(ap);
1804 }
1805
1806 #ifdef CONFIG_PM
1807 static int nv_swncq_port_suspend(struct ata_port *ap, pm_message_t mesg)
1808 {
1809         void __iomem *mmio = ap->host->iomap[NV_MMIO_BAR];
1810         u32 tmp;
1811
1812         /* clear irq */
1813         writel(~0, mmio + NV_INT_STATUS_MCP55);
1814
1815         /* disable irq */
1816         writel(0, mmio + NV_INT_ENABLE_MCP55);
1817
1818         /* disable swncq */
1819         tmp = readl(mmio + NV_CTL_MCP55);
1820         tmp &= ~(NV_CTL_PRI_SWNCQ | NV_CTL_SEC_SWNCQ);
1821         writel(tmp, mmio + NV_CTL_MCP55);
1822
1823         return 0;
1824 }
1825
1826 static int nv_swncq_port_resume(struct ata_port *ap)
1827 {
1828         void __iomem *mmio = ap->host->iomap[NV_MMIO_BAR];
1829         u32 tmp;
1830
1831         /* clear irq */
1832         writel(~0, mmio + NV_INT_STATUS_MCP55);
1833
1834         /* enable irq */
1835         writel(0x00fd00fd, mmio + NV_INT_ENABLE_MCP55);
1836
1837         /* enable swncq */
1838         tmp = readl(mmio + NV_CTL_MCP55);
1839         writel(tmp | NV_CTL_PRI_SWNCQ | NV_CTL_SEC_SWNCQ, mmio + NV_CTL_MCP55);
1840
1841         return 0;
1842 }
1843 #endif
1844
1845 static void nv_swncq_host_init(struct ata_host *host)
1846 {
1847         u32 tmp;
1848         void __iomem *mmio = host->iomap[NV_MMIO_BAR];
1849         struct pci_dev *pdev = to_pci_dev(host->dev);
1850         u8 regval;
1851
1852         /* disable  ECO 398 */
1853         pci_read_config_byte(pdev, 0x7f, &regval);
1854         regval &= ~(1 << 7);
1855         pci_write_config_byte(pdev, 0x7f, regval);
1856
1857         /* enable swncq */
1858         tmp = readl(mmio + NV_CTL_MCP55);
1859         dev_dbg(&pdev->dev, "HOST_CTL:0x%X\n", tmp);
1860         writel(tmp | NV_CTL_PRI_SWNCQ | NV_CTL_SEC_SWNCQ, mmio + NV_CTL_MCP55);
1861
1862         /* enable irq intr */
1863         tmp = readl(mmio + NV_INT_ENABLE_MCP55);
1864         dev_dbg(&pdev->dev, "HOST_ENABLE:0x%X\n", tmp);
1865         writel(tmp | 0x00fd00fd, mmio + NV_INT_ENABLE_MCP55);
1866
1867         /*  clear port irq */
1868         writel(~0x0, mmio + NV_INT_STATUS_MCP55);
1869 }
1870
1871 static int nv_swncq_slave_config(struct scsi_device *sdev)
1872 {
1873         struct ata_port *ap = ata_shost_to_port(sdev->host);
1874         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
1875         struct ata_device *dev;
1876         int rc;
1877         u8 rev;
1878         u8 check_maxtor = 0;
1879         unsigned char model_num[ATA_ID_PROD_LEN + 1];
1880
1881         rc = ata_scsi_slave_config(sdev);
1882         if (sdev->id >= ATA_MAX_DEVICES || sdev->channel || sdev->lun)
1883                 /* Not a proper libata device, ignore */
1884                 return rc;
1885
1886         dev = &ap->link.device[sdev->id];
1887         if (!(ap->flags & ATA_FLAG_NCQ) || dev->class == ATA_DEV_ATAPI)
1888                 return rc;
1889
1890         /* if MCP51 and Maxtor, then disable ncq */
1891         if (pdev->device == PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_SATA ||
1892                 pdev->device == PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_SATA2)
1893                 check_maxtor = 1;
1894
1895         /* if MCP55 and rev <= a2 and Maxtor, then disable ncq */
1896         if (pdev->device == PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SATA ||
1897                 pdev->device == PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SATA2) {
1898                 pci_read_config_byte(pdev, 0x8, &rev);
1899                 if (rev <= 0xa2)
1900                         check_maxtor = 1;
1901         }
1902
1903         if (!check_maxtor)
1904                 return rc;
1905
1906         ata_id_c_string(dev->id, model_num, ATA_ID_PROD, sizeof(model_num));
1907
1908         if (strncmp(model_num, "Maxtor", 6) == 0) {
1909                 ata_scsi_change_queue_depth(sdev, 1);
1910                 ata_dev_notice(dev, "Disabling SWNCQ mode (depth %x)\n",
1911                                sdev->queue_depth);
1912         }
1913
1914         return rc;
1915 }
1916
1917 static int nv_swncq_port_start(struct ata_port *ap)
1918 {
1919         struct device *dev = ap->host->dev;
1920         void __iomem *mmio = ap->host->iomap[NV_MMIO_BAR];
1921         struct nv_swncq_port_priv *pp;
1922         int rc;
1923
1924         /* we might fallback to bmdma, allocate bmdma resources */
1925         rc = ata_bmdma_port_start(ap);
1926         if (rc)
1927                 return rc;
1928
1929         pp = devm_kzalloc(dev, sizeof(*pp), GFP_KERNEL);
1930         if (!pp)
1931                 return -ENOMEM;
1932
1933         pp->prd = dmam_alloc_coherent(dev, ATA_PRD_TBL_SZ * ATA_MAX_QUEUE,
1934                                       &pp->prd_dma, GFP_KERNEL);
1935         if (!pp->prd)
1936                 return -ENOMEM;
1937
1938         ap->private_data = pp;
1939         pp->sactive_block = ap->ioaddr.scr_addr + 4 * SCR_ACTIVE;
1940         pp->irq_block = mmio + NV_INT_STATUS_MCP55 + ap->port_no * 2;
1941         pp->tag_block = mmio + NV_NCQ_REG_MCP55 + ap->port_no * 2;
1942
1943         return 0;
1944 }
1945
1946 static enum ata_completion_errors nv_swncq_qc_prep(struct ata_queued_cmd *qc)
1947 {
1948         if (qc->tf.protocol != ATA_PROT_NCQ) {
1949                 ata_bmdma_qc_prep(qc);
1950                 return AC_ERR_OK;
1951         }
1952
1953         if (!(qc->flags & ATA_QCFLAG_DMAMAP))
1954                 return AC_ERR_OK;
1955
1956         nv_swncq_fill_sg(qc);
1957
1958         return AC_ERR_OK;
1959 }
1960
1961 static void nv_swncq_fill_sg(struct ata_queued_cmd *qc)
1962 {
1963         struct ata_port *ap = qc->ap;
1964         struct scatterlist *sg;
1965         struct nv_swncq_port_priv *pp = ap->private_data;
1966         struct ata_bmdma_prd *prd;
1967         unsigned int si, idx;
1968
1969         prd = pp->prd + ATA_MAX_PRD * qc->hw_tag;
1970
1971         idx = 0;
1972         for_each_sg(qc->sg, sg, qc->n_elem, si) {
1973                 u32 addr, offset;
1974                 u32 sg_len, len;
1975
1976                 addr = (u32)sg_dma_address(sg);
1977                 sg_len = sg_dma_len(sg);
1978
1979                 while (sg_len) {
1980                         offset = addr & 0xffff;
1981                         len = sg_len;
1982                         if ((offset + sg_len) > 0x10000)
1983                                 len = 0x10000 - offset;
1984
1985                         prd[idx].addr = cpu_to_le32(addr);
1986                         prd[idx].flags_len = cpu_to_le32(len & 0xffff);
1987
1988                         idx++;
1989                         sg_len -= len;
1990                         addr += len;
1991                 }
1992         }
1993
1994         prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
1995 }
1996
1997 static unsigned int nv_swncq_issue_atacmd(struct ata_port *ap,
1998                                           struct ata_queued_cmd *qc)
1999 {
2000         struct nv_swncq_port_priv *pp = ap->private_data;
2001
2002         if (qc == NULL)
2003                 return 0;
2004
2005         writel((1 << qc->hw_tag), pp->sactive_block);
2006         pp->last_issue_tag = qc->hw_tag;
2007         pp->dhfis_bits &= ~(1 << qc->hw_tag);
2008         pp->dmafis_bits &= ~(1 << qc->hw_tag);
2009         pp->qc_active |= (0x1 << qc->hw_tag);
2010
2011         trace_ata_tf_load(ap, &qc->tf);
2012         ap->ops->sff_tf_load(ap, &qc->tf);       /* load tf registers */
2013         trace_ata_exec_command(ap, &qc->tf, qc->hw_tag);
2014         ap->ops->sff_exec_command(ap, &qc->tf);
2015
2016         return 0;
2017 }
2018
2019 static unsigned int nv_swncq_qc_issue(struct ata_queued_cmd *qc)
2020 {
2021         struct ata_port *ap = qc->ap;
2022         struct nv_swncq_port_priv *pp = ap->private_data;
2023
2024         if (qc->tf.protocol != ATA_PROT_NCQ)
2025                 return ata_bmdma_qc_issue(qc);
2026
2027         if (!pp->qc_active)
2028                 nv_swncq_issue_atacmd(ap, qc);
2029         else
2030                 nv_swncq_qc_to_dq(ap, qc);      /* add qc to defer queue */
2031
2032         return 0;
2033 }
2034
2035 static void nv_swncq_hotplug(struct ata_port *ap, u32 fis)
2036 {
2037         u32 serror;
2038         struct ata_eh_info *ehi = &ap->link.eh_info;
2039
2040         ata_ehi_clear_desc(ehi);
2041
2042         /* AHCI needs SError cleared; otherwise, it might lock up */
2043         sata_scr_read(&ap->link, SCR_ERROR, &serror);
2044         sata_scr_write(&ap->link, SCR_ERROR, serror);
2045
2046         /* analyze @irq_stat */
2047         if (fis & NV_SWNCQ_IRQ_ADDED)
2048                 ata_ehi_push_desc(ehi, "hot plug");
2049         else if (fis & NV_SWNCQ_IRQ_REMOVED)
2050                 ata_ehi_push_desc(ehi, "hot unplug");
2051
2052         ata_ehi_hotplugged(ehi);
2053
2054         /* okay, let's hand over to EH */
2055         ehi->serror |= serror;
2056
2057         ata_port_freeze(ap);
2058 }
2059
2060 static int nv_swncq_sdbfis(struct ata_port *ap)
2061 {
2062         struct ata_queued_cmd *qc;
2063         struct nv_swncq_port_priv *pp = ap->private_data;
2064         struct ata_eh_info *ehi = &ap->link.eh_info;
2065         u32 sactive;
2066         u32 done_mask;
2067         u8 host_stat;
2068         u8 lack_dhfis = 0;
2069
2070         host_stat = ap->ops->bmdma_status(ap);
2071         trace_ata_bmdma_status(ap, host_stat);
2072         if (unlikely(host_stat & ATA_DMA_ERR)) {
2073                 /* error when transferring data to/from memory */
2074                 ata_ehi_clear_desc(ehi);
2075                 ata_ehi_push_desc(ehi, "BMDMA stat 0x%x", host_stat);
2076                 ehi->err_mask |= AC_ERR_HOST_BUS;
2077                 ehi->action |= ATA_EH_RESET;
2078                 return -EINVAL;
2079         }
2080
2081         ap->ops->sff_irq_clear(ap);
2082         __ata_bmdma_stop(ap);
2083
2084         sactive = readl(pp->sactive_block);
2085         done_mask = pp->qc_active ^ sactive;
2086
2087         pp->qc_active &= ~done_mask;
2088         pp->dhfis_bits &= ~done_mask;
2089         pp->dmafis_bits &= ~done_mask;
2090         pp->sdbfis_bits |= done_mask;
2091         ata_qc_complete_multiple(ap, ata_qc_get_active(ap) ^ done_mask);
2092
2093         if (!ap->qc_active) {
2094                 ata_port_dbg(ap, "over\n");
2095                 nv_swncq_pp_reinit(ap);
2096                 return 0;
2097         }
2098
2099         if (pp->qc_active & pp->dhfis_bits)
2100                 return 0;
2101
2102         if ((pp->ncq_flags & ncq_saw_backout) ||
2103             (pp->qc_active ^ pp->dhfis_bits))
2104                 /* if the controller can't get a device to host register FIS,
2105                  * The driver needs to reissue the new command.
2106                  */
2107                 lack_dhfis = 1;
2108
2109         ata_port_dbg(ap, "QC: qc_active 0x%llx,"
2110                      "SWNCQ:qc_active 0x%X defer_bits %X "
2111                      "dhfis 0x%X dmafis 0x%X last_issue_tag %x\n",
2112                      ap->qc_active, pp->qc_active,
2113                      pp->defer_queue.defer_bits, pp->dhfis_bits,
2114                      pp->dmafis_bits, pp->last_issue_tag);
2115
2116         nv_swncq_fis_reinit(ap);
2117
2118         if (lack_dhfis) {
2119                 qc = ata_qc_from_tag(ap, pp->last_issue_tag);
2120                 nv_swncq_issue_atacmd(ap, qc);
2121                 return 0;
2122         }
2123
2124         if (pp->defer_queue.defer_bits) {
2125                 /* send deferral queue command */
2126                 qc = nv_swncq_qc_from_dq(ap);
2127                 WARN_ON(qc == NULL);
2128                 nv_swncq_issue_atacmd(ap, qc);
2129         }
2130
2131         return 0;
2132 }
2133
2134 static inline u32 nv_swncq_tag(struct ata_port *ap)
2135 {
2136         struct nv_swncq_port_priv *pp = ap->private_data;
2137         u32 tag;
2138
2139         tag = readb(pp->tag_block) >> 2;
2140         return (tag & 0x1f);
2141 }
2142
2143 static void nv_swncq_dmafis(struct ata_port *ap)
2144 {
2145         struct ata_queued_cmd *qc;
2146         unsigned int rw;
2147         u8 dmactl;
2148         u32 tag;
2149         struct nv_swncq_port_priv *pp = ap->private_data;
2150
2151         __ata_bmdma_stop(ap);
2152         tag = nv_swncq_tag(ap);
2153
2154         ata_port_dbg(ap, "dma setup tag 0x%x\n", tag);
2155         qc = ata_qc_from_tag(ap, tag);
2156
2157         if (unlikely(!qc))
2158                 return;
2159
2160         rw = qc->tf.flags & ATA_TFLAG_WRITE;
2161
2162         /* load PRD table addr. */
2163         iowrite32(pp->prd_dma + ATA_PRD_TBL_SZ * qc->hw_tag,
2164                   ap->ioaddr.bmdma_addr + ATA_DMA_TABLE_OFS);
2165
2166         /* specify data direction, triple-check start bit is clear */
2167         dmactl = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
2168         dmactl &= ~ATA_DMA_WR;
2169         if (!rw)
2170                 dmactl |= ATA_DMA_WR;
2171
2172         iowrite8(dmactl | ATA_DMA_START, ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
2173 }
2174
2175 static void nv_swncq_host_interrupt(struct ata_port *ap, u16 fis)
2176 {
2177         struct nv_swncq_port_priv *pp = ap->private_data;
2178         struct ata_queued_cmd *qc;
2179         struct ata_eh_info *ehi = &ap->link.eh_info;
2180         u32 serror;
2181         u8 ata_stat;
2182
2183         ata_stat = ap->ops->sff_check_status(ap);
2184         nv_swncq_irq_clear(ap, fis);
2185         if (!fis)
2186                 return;
2187
2188         if (ata_port_is_frozen(ap))
2189                 return;
2190
2191         if (fis & NV_SWNCQ_IRQ_HOTPLUG) {
2192                 nv_swncq_hotplug(ap, fis);
2193                 return;
2194         }
2195
2196         if (!pp->qc_active)
2197                 return;
2198
2199         if (ap->ops->scr_read(&ap->link, SCR_ERROR, &serror))
2200                 return;
2201         ap->ops->scr_write(&ap->link, SCR_ERROR, serror);
2202
2203         if (ata_stat & ATA_ERR) {
2204                 ata_ehi_clear_desc(ehi);
2205                 ata_ehi_push_desc(ehi, "Ata error. fis:0x%X", fis);
2206                 ehi->err_mask |= AC_ERR_DEV;
2207                 ehi->serror |= serror;
2208                 ehi->action |= ATA_EH_RESET;
2209                 ata_port_freeze(ap);
2210                 return;
2211         }
2212
2213         if (fis & NV_SWNCQ_IRQ_BACKOUT) {
2214                 /* If the IRQ is backout, driver must issue
2215                  * the new command again some time later.
2216                  */
2217                 pp->ncq_flags |= ncq_saw_backout;
2218         }
2219
2220         if (fis & NV_SWNCQ_IRQ_SDBFIS) {
2221                 pp->ncq_flags |= ncq_saw_sdb;
2222                 ata_port_dbg(ap, "SWNCQ: qc_active 0x%X "
2223                         "dhfis 0x%X dmafis 0x%X sactive 0x%X\n",
2224                         pp->qc_active, pp->dhfis_bits,
2225                         pp->dmafis_bits, readl(pp->sactive_block));
2226                 if (nv_swncq_sdbfis(ap) < 0)
2227                         goto irq_error;
2228         }
2229
2230         if (fis & NV_SWNCQ_IRQ_DHREGFIS) {
2231                 /* The interrupt indicates the new command
2232                  * was transmitted correctly to the drive.
2233                  */
2234                 pp->dhfis_bits |= (0x1 << pp->last_issue_tag);
2235                 pp->ncq_flags |= ncq_saw_d2h;
2236                 if (pp->ncq_flags & (ncq_saw_sdb | ncq_saw_backout)) {
2237                         ata_ehi_push_desc(ehi, "illegal fis transaction");
2238                         ehi->err_mask |= AC_ERR_HSM;
2239                         ehi->action |= ATA_EH_RESET;
2240                         goto irq_error;
2241                 }
2242
2243                 if (!(fis & NV_SWNCQ_IRQ_DMASETUP) &&
2244                     !(pp->ncq_flags & ncq_saw_dmas)) {
2245                         ata_stat = ap->ops->sff_check_status(ap);
2246                         if (ata_stat & ATA_BUSY)
2247                                 goto irq_exit;
2248
2249                         if (pp->defer_queue.defer_bits) {
2250                                 ata_port_dbg(ap, "send next command\n");
2251                                 qc = nv_swncq_qc_from_dq(ap);
2252                                 nv_swncq_issue_atacmd(ap, qc);
2253                         }
2254                 }
2255         }
2256
2257         if (fis & NV_SWNCQ_IRQ_DMASETUP) {
2258                 /* program the dma controller with appropriate PRD buffers
2259                  * and start the DMA transfer for requested command.
2260                  */
2261                 pp->dmafis_bits |= (0x1 << nv_swncq_tag(ap));
2262                 pp->ncq_flags |= ncq_saw_dmas;
2263                 nv_swncq_dmafis(ap);
2264         }
2265
2266 irq_exit:
2267         return;
2268 irq_error:
2269         ata_ehi_push_desc(ehi, "fis:0x%x", fis);
2270         ata_port_freeze(ap);
2271         return;
2272 }
2273
2274 static irqreturn_t nv_swncq_interrupt(int irq, void *dev_instance)
2275 {
2276         struct ata_host *host = dev_instance;
2277         unsigned int i;
2278         unsigned int handled = 0;
2279         unsigned long flags;
2280         u32 irq_stat;
2281
2282         spin_lock_irqsave(&host->lock, flags);
2283
2284         irq_stat = readl(host->iomap[NV_MMIO_BAR] + NV_INT_STATUS_MCP55);
2285
2286         for (i = 0; i < host->n_ports; i++) {
2287                 struct ata_port *ap = host->ports[i];
2288
2289                 if (ap->link.sactive) {
2290                         nv_swncq_host_interrupt(ap, (u16)irq_stat);
2291                         handled = 1;
2292                 } else {
2293                         if (irq_stat)   /* reserve Hotplug */
2294                                 nv_swncq_irq_clear(ap, 0xfff0);
2295
2296                         handled += nv_host_intr(ap, (u8)irq_stat);
2297                 }
2298                 irq_stat >>= NV_INT_PORT_SHIFT_MCP55;
2299         }
2300
2301         spin_unlock_irqrestore(&host->lock, flags);
2302
2303         return IRQ_RETVAL(handled);
2304 }
2305
2306 static int nv_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
2307 {
2308         const struct ata_port_info *ppi[] = { NULL, NULL };
2309         struct nv_pi_priv *ipriv;
2310         struct ata_host *host;
2311         struct nv_host_priv *hpriv;
2312         int rc;
2313         u32 bar;
2314         void __iomem *base;
2315         unsigned long type = ent->driver_data;
2316
2317         // Make sure this is a SATA controller by counting the number of bars
2318         // (NVIDIA SATA controllers will always have six bars).  Otherwise,
2319         // it's an IDE controller and we ignore it.
2320         for (bar = 0; bar < PCI_STD_NUM_BARS; bar++)
2321                 if (pci_resource_start(pdev, bar) == 0)
2322                         return -ENODEV;
2323
2324         ata_print_version_once(&pdev->dev, DRV_VERSION);
2325
2326         rc = pcim_enable_device(pdev);
2327         if (rc)
2328                 return rc;
2329
2330         /* determine type and allocate host */
2331         if (type == CK804 && adma_enabled) {
2332                 dev_notice(&pdev->dev, "Using ADMA mode\n");
2333                 type = ADMA;
2334         } else if (type == MCP5x && swncq_enabled) {
2335                 dev_notice(&pdev->dev, "Using SWNCQ mode\n");
2336                 type = SWNCQ;
2337         }
2338
2339         ppi[0] = &nv_port_info[type];
2340         ipriv = ppi[0]->private_data;
2341         rc = ata_pci_bmdma_prepare_host(pdev, ppi, &host);
2342         if (rc)
2343                 return rc;
2344
2345         hpriv = devm_kzalloc(&pdev->dev, sizeof(*hpriv), GFP_KERNEL);
2346         if (!hpriv)
2347                 return -ENOMEM;
2348         hpriv->type = type;
2349         host->private_data = hpriv;
2350
2351         /* request and iomap NV_MMIO_BAR */
2352         rc = pcim_iomap_regions(pdev, 1 << NV_MMIO_BAR, DRV_NAME);
2353         if (rc)
2354                 return rc;
2355
2356         /* configure SCR access */
2357         base = host->iomap[NV_MMIO_BAR];
2358         host->ports[0]->ioaddr.scr_addr = base + NV_PORT0_SCR_REG_OFFSET;
2359         host->ports[1]->ioaddr.scr_addr = base + NV_PORT1_SCR_REG_OFFSET;
2360
2361         /* enable SATA space for CK804 */
2362         if (type >= CK804) {
2363                 u8 regval;
2364
2365                 pci_read_config_byte(pdev, NV_MCP_SATA_CFG_20, &regval);
2366                 regval |= NV_MCP_SATA_CFG_20_SATA_SPACE_EN;
2367                 pci_write_config_byte(pdev, NV_MCP_SATA_CFG_20, regval);
2368         }
2369
2370         /* init ADMA */
2371         if (type == ADMA) {
2372                 rc = nv_adma_host_init(host);
2373                 if (rc)
2374                         return rc;
2375         } else if (type == SWNCQ)
2376                 nv_swncq_host_init(host);
2377
2378         if (msi_enabled) {
2379                 dev_notice(&pdev->dev, "Using MSI\n");
2380                 pci_enable_msi(pdev);
2381         }
2382
2383         pci_set_master(pdev);
2384         return ata_pci_sff_activate_host(host, ipriv->irq_handler, ipriv->sht);
2385 }
2386
2387 #ifdef CONFIG_PM_SLEEP
2388 static int nv_pci_device_resume(struct pci_dev *pdev)
2389 {
2390         struct ata_host *host = pci_get_drvdata(pdev);
2391         struct nv_host_priv *hpriv = host->private_data;
2392         int rc;
2393
2394         rc = ata_pci_device_do_resume(pdev);
2395         if (rc)
2396                 return rc;
2397
2398         if (pdev->dev.power.power_state.event == PM_EVENT_SUSPEND) {
2399                 if (hpriv->type >= CK804) {
2400                         u8 regval;
2401
2402                         pci_read_config_byte(pdev, NV_MCP_SATA_CFG_20, &regval);
2403                         regval |= NV_MCP_SATA_CFG_20_SATA_SPACE_EN;
2404                         pci_write_config_byte(pdev, NV_MCP_SATA_CFG_20, regval);
2405                 }
2406                 if (hpriv->type == ADMA) {
2407                         u32 tmp32;
2408                         struct nv_adma_port_priv *pp;
2409                         /* enable/disable ADMA on the ports appropriately */
2410                         pci_read_config_dword(pdev, NV_MCP_SATA_CFG_20, &tmp32);
2411
2412                         pp = host->ports[0]->private_data;
2413                         if (pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE)
2414                                 tmp32 &= ~(NV_MCP_SATA_CFG_20_PORT0_EN |
2415                                            NV_MCP_SATA_CFG_20_PORT0_PWB_EN);
2416                         else
2417                                 tmp32 |=  (NV_MCP_SATA_CFG_20_PORT0_EN |
2418                                            NV_MCP_SATA_CFG_20_PORT0_PWB_EN);
2419                         pp = host->ports[1]->private_data;
2420                         if (pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE)
2421                                 tmp32 &= ~(NV_MCP_SATA_CFG_20_PORT1_EN |
2422                                            NV_MCP_SATA_CFG_20_PORT1_PWB_EN);
2423                         else
2424                                 tmp32 |=  (NV_MCP_SATA_CFG_20_PORT1_EN |
2425                                            NV_MCP_SATA_CFG_20_PORT1_PWB_EN);
2426
2427                         pci_write_config_dword(pdev, NV_MCP_SATA_CFG_20, tmp32);
2428                 }
2429         }
2430
2431         ata_host_resume(host);
2432
2433         return 0;
2434 }
2435 #endif
2436
2437 static void nv_ck804_host_stop(struct ata_host *host)
2438 {
2439         struct pci_dev *pdev = to_pci_dev(host->dev);
2440         u8 regval;
2441
2442         /* disable SATA space for CK804 */
2443         pci_read_config_byte(pdev, NV_MCP_SATA_CFG_20, &regval);
2444         regval &= ~NV_MCP_SATA_CFG_20_SATA_SPACE_EN;
2445         pci_write_config_byte(pdev, NV_MCP_SATA_CFG_20, regval);
2446 }
2447
2448 static void nv_adma_host_stop(struct ata_host *host)
2449 {
2450         struct pci_dev *pdev = to_pci_dev(host->dev);
2451         u32 tmp32;
2452
2453         /* disable ADMA on the ports */
2454         pci_read_config_dword(pdev, NV_MCP_SATA_CFG_20, &tmp32);
2455         tmp32 &= ~(NV_MCP_SATA_CFG_20_PORT0_EN |
2456                    NV_MCP_SATA_CFG_20_PORT0_PWB_EN |
2457                    NV_MCP_SATA_CFG_20_PORT1_EN |
2458                    NV_MCP_SATA_CFG_20_PORT1_PWB_EN);
2459
2460         pci_write_config_dword(pdev, NV_MCP_SATA_CFG_20, tmp32);
2461
2462         nv_ck804_host_stop(host);
2463 }
2464
2465 module_pci_driver(nv_pci_driver);
2466
2467 module_param_named(adma, adma_enabled, bool, 0444);
2468 MODULE_PARM_DESC(adma, "Enable use of ADMA (Default: false)");
2469 module_param_named(swncq, swncq_enabled, bool, 0444);
2470 MODULE_PARM_DESC(swncq, "Enable use of SWNCQ (Default: true)");
2471 module_param_named(msi, msi_enabled, bool, 0444);
2472 MODULE_PARM_DESC(msi, "Enable use of MSI (Default: false)");