drivers/ata/sata_nv.c

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