git.oblomov.eu Git - linux-2.6/blob - 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.3"
  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                     = 0x1f,
  61         NV_MWDMA_MASK                   = 0x07,
  62         NV_UDMA_MASK                    = 0x7f,
  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 };
 173
 174 /* ADMA Physical Region Descriptor - one SG segment */
 175 struct nv_adma_prd {
 176         __le64                  addr;
 177         __le32                  len;
 178         u8                      flags;
 179         u8                      packet_len;
 180         __le16                  reserved;
 181 };
 182
 183 enum nv_adma_regbits {
 184         CMDEND  = (1 << 15),            /* end of command list */
 185         WNB     = (1 << 14),            /* wait-not-BSY */
 186         IGN     = (1 << 13),            /* ignore this entry */
 187         CS1n    = (1 << (4 + 8)),       /* std. PATA signals follow... */
 188         DA2     = (1 << (2 + 8)),
 189         DA1     = (1 << (1 + 8)),
 190         DA0     = (1 << (0 + 8)),
 191 };
 192
 193 /* ADMA Command Parameter Block
 194    The first 5 SG segments are stored inside the Command Parameter Block itself.
 195    If there are more than 5 segments the remainder are stored in a separate
 196    memory area indicated by next_aprd. */
 197 struct nv_adma_cpb {
 198         u8                      resp_flags;    /* 0 */
 199         u8                      reserved1;     /* 1 */
 200         u8                      ctl_flags;     /* 2 */
 201         /* len is length of taskfile in 64 bit words */
 202         u8                      len;           /* 3  */
 203         u8                      tag;           /* 4 */
 204         u8                      next_cpb_idx;  /* 5 */
 205         __le16                  reserved2;     /* 6-7 */
 206         __le16                  tf[12];        /* 8-31 */
 207         struct nv_adma_prd      aprd[5];       /* 32-111 */
 208         __le64                  next_aprd;     /* 112-119 */
 209         __le64                  reserved3;     /* 120-127 */
 210 };
 211
 212
 213 struct nv_adma_port_priv {
 214         struct nv_adma_cpb      *cpb;
 215         dma_addr_t              cpb_dma;
 216         struct nv_adma_prd      *aprd;
 217         dma_addr_t              aprd_dma;
 218         void __iomem *          ctl_block;
 219         void __iomem *          gen_block;
 220         void __iomem *          notifier_clear_block;
 221         u8                      flags;
 222         int                     last_issue_ncq;
 223 };
 224
 225 struct nv_host_priv {
 226         unsigned long           type;
 227 };
 228
 229 #define NV_ADMA_CHECK_INTR(GCTL, PORT) ((GCTL) & ( 1 << (19 + (12 * (PORT)))))
 230
 231 static int nv_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
 232 static void nv_remove_one (struct pci_dev *pdev);
 233 #ifdef CONFIG_PM
 234 static int nv_pci_device_resume(struct pci_dev *pdev);
 235 #endif
 236 static void nv_ck804_host_stop(struct ata_host *host);
 237 static irqreturn_t nv_generic_interrupt(int irq, void *dev_instance);
 238 static irqreturn_t nv_nf2_interrupt(int irq, void *dev_instance);
 239 static irqreturn_t nv_ck804_interrupt(int irq, void *dev_instance);
 240 static u32 nv_scr_read (struct ata_port *ap, unsigned int sc_reg);
 241 static void nv_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
 242
 243 static void nv_nf2_freeze(struct ata_port *ap);
 244 static void nv_nf2_thaw(struct ata_port *ap);
 245 static void nv_ck804_freeze(struct ata_port *ap);
 246 static void nv_ck804_thaw(struct ata_port *ap);
 247 static void nv_error_handler(struct ata_port *ap);
 248 static int nv_adma_slave_config(struct scsi_device *sdev);
 249 static int nv_adma_check_atapi_dma(struct ata_queued_cmd *qc);
 250 static void nv_adma_qc_prep(struct ata_queued_cmd *qc);
 251 static unsigned int nv_adma_qc_issue(struct ata_queued_cmd *qc);
 252 static irqreturn_t nv_adma_interrupt(int irq, void *dev_instance);
 253 static void nv_adma_irq_clear(struct ata_port *ap);
 254 static int nv_adma_port_start(struct ata_port *ap);
 255 static void nv_adma_port_stop(struct ata_port *ap);
 256 #ifdef CONFIG_PM
 257 static int nv_adma_port_suspend(struct ata_port *ap, pm_message_t mesg);
 258 static int nv_adma_port_resume(struct ata_port *ap);
 259 #endif
 260 static void nv_adma_error_handler(struct ata_port *ap);
 261 static void nv_adma_host_stop(struct ata_host *host);
 262 static void nv_adma_post_internal_cmd(struct ata_queued_cmd *qc);
 263
 264 enum nv_host_type
 265 {
 266         GENERIC,
 267         NFORCE2,
 268         NFORCE3 = NFORCE2,      /* NF2 == NF3 as far as sata_nv is concerned */
 269         CK804,
 270         ADMA
 271 };
 272
 273 static const struct pci_device_id nv_pci_tbl[] = {
 274         { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE2S_SATA), NFORCE2 },
 275         { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE3S_SATA), NFORCE3 },
 276         { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE3S_SATA2), NFORCE3 },
 277         { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_CK804_SATA), CK804 },
 278         { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_CK804_SATA2), CK804 },
 279         { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_SATA), CK804 },
 280         { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_SATA2), CK804 },
 281         { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_SATA), GENERIC },
 282         { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_SATA2), GENERIC },
 283         { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SATA), GENERIC },
 284         { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SATA2), GENERIC },
 285         { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SATA), GENERIC },
 286         { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SATA2), GENERIC },
 287         { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SATA3), GENERIC },
 288         { PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID,
 289                 PCI_ANY_ID, PCI_ANY_ID,
 290                 PCI_CLASS_STORAGE_IDE<<8, 0xffff00, GENERIC },
 291         { PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID,
 292                 PCI_ANY_ID, PCI_ANY_ID,
 293                 PCI_CLASS_STORAGE_RAID<<8, 0xffff00, GENERIC },
 294
 295         { } /* terminate list */
 296 };
 297
 298 static struct pci_driver nv_pci_driver = {
 299         .name                   = DRV_NAME,
 300         .id_table               = nv_pci_tbl,
 301         .probe                  = nv_init_one,
 302 #ifdef CONFIG_PM
 303         .suspend                = ata_pci_device_suspend,
 304         .resume                 = nv_pci_device_resume,
 305 #endif
 306         .remove                 = nv_remove_one,
 307 };
 308
 309 static struct scsi_host_template nv_sht = {
 310         .module                 = THIS_MODULE,
 311         .name                   = DRV_NAME,
 312         .ioctl                  = ata_scsi_ioctl,
 313         .queuecommand           = ata_scsi_queuecmd,
 314         .can_queue              = ATA_DEF_QUEUE,
 315         .this_id                = ATA_SHT_THIS_ID,
 316         .sg_tablesize           = LIBATA_MAX_PRD,
 317         .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
 318         .emulated               = ATA_SHT_EMULATED,
 319         .use_clustering         = ATA_SHT_USE_CLUSTERING,
 320         .proc_name              = DRV_NAME,
 321         .dma_boundary           = ATA_DMA_BOUNDARY,
 322         .slave_configure        = ata_scsi_slave_config,
 323         .slave_destroy          = ata_scsi_slave_destroy,
 324         .bios_param             = ata_std_bios_param,
 325 #ifdef CONFIG_PM
 326         .suspend                = ata_scsi_device_suspend,
 327         .resume                 = ata_scsi_device_resume,
 328 #endif
 329 };
 330
 331 static struct scsi_host_template nv_adma_sht = {
 332         .module                 = THIS_MODULE,
 333         .name                   = DRV_NAME,
 334         .ioctl                  = ata_scsi_ioctl,
 335         .queuecommand           = ata_scsi_queuecmd,
 336         .can_queue              = NV_ADMA_MAX_CPBS,
 337         .this_id                = ATA_SHT_THIS_ID,
 338         .sg_tablesize           = NV_ADMA_SGTBL_TOTAL_LEN,
 339         .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
 340         .emulated               = ATA_SHT_EMULATED,
 341         .use_clustering         = ATA_SHT_USE_CLUSTERING,
 342         .proc_name              = DRV_NAME,
 343         .dma_boundary           = NV_ADMA_DMA_BOUNDARY,
 344         .slave_configure        = nv_adma_slave_config,
 345         .slave_destroy          = ata_scsi_slave_destroy,
 346         .bios_param             = ata_std_bios_param,
 347 #ifdef CONFIG_PM
 348         .suspend                = ata_scsi_device_suspend,
 349         .resume                 = ata_scsi_device_resume,
 350 #endif
 351 };
 352
 353 static const struct ata_port_operations nv_generic_ops = {
 354         .port_disable           = ata_port_disable,
 355         .tf_load                = ata_tf_load,
 356         .tf_read                = ata_tf_read,
 357         .exec_command           = ata_exec_command,
 358         .check_status           = ata_check_status,
 359         .dev_select             = ata_std_dev_select,
 360         .bmdma_setup            = ata_bmdma_setup,
 361         .bmdma_start            = ata_bmdma_start,
 362         .bmdma_stop             = ata_bmdma_stop,
 363         .bmdma_status           = ata_bmdma_status,
 364         .qc_prep                = ata_qc_prep,
 365         .qc_issue               = ata_qc_issue_prot,
 366         .freeze                 = ata_bmdma_freeze,
 367         .thaw                   = ata_bmdma_thaw,
 368         .error_handler          = nv_error_handler,
 369         .post_internal_cmd      = ata_bmdma_post_internal_cmd,
 370         .data_xfer              = ata_data_xfer,
 371         .irq_handler            = nv_generic_interrupt,
 372         .irq_clear              = ata_bmdma_irq_clear,
 373         .irq_on                 = ata_irq_on,
 374         .irq_ack                = ata_irq_ack,
 375         .scr_read               = nv_scr_read,
 376         .scr_write              = nv_scr_write,
 377         .port_start             = ata_port_start,
 378 };
 379
 380 static const struct ata_port_operations nv_nf2_ops = {
 381         .port_disable           = ata_port_disable,
 382         .tf_load                = ata_tf_load,
 383         .tf_read                = ata_tf_read,
 384         .exec_command           = ata_exec_command,
 385         .check_status           = ata_check_status,
 386         .dev_select             = ata_std_dev_select,
 387         .bmdma_setup            = ata_bmdma_setup,
 388         .bmdma_start            = ata_bmdma_start,
 389         .bmdma_stop             = ata_bmdma_stop,
 390         .bmdma_status           = ata_bmdma_status,
 391         .qc_prep                = ata_qc_prep,
 392         .qc_issue               = ata_qc_issue_prot,
 393         .freeze                 = nv_nf2_freeze,
 394         .thaw                   = nv_nf2_thaw,
 395         .error_handler          = nv_error_handler,
 396         .post_internal_cmd      = ata_bmdma_post_internal_cmd,
 397         .data_xfer              = ata_data_xfer,
 398         .irq_handler            = nv_nf2_interrupt,
 399         .irq_clear              = ata_bmdma_irq_clear,
 400         .irq_on                 = ata_irq_on,
 401         .irq_ack                = ata_irq_ack,
 402         .scr_read               = nv_scr_read,
 403         .scr_write              = nv_scr_write,
 404         .port_start             = ata_port_start,
 405 };
 406
 407 static const struct ata_port_operations nv_ck804_ops = {
 408         .port_disable           = ata_port_disable,
 409         .tf_load                = ata_tf_load,
 410         .tf_read                = ata_tf_read,
 411         .exec_command           = ata_exec_command,
 412         .check_status           = ata_check_status,
 413         .dev_select             = ata_std_dev_select,
 414         .bmdma_setup            = ata_bmdma_setup,
 415         .bmdma_start            = ata_bmdma_start,
 416         .bmdma_stop             = ata_bmdma_stop,
 417         .bmdma_status           = ata_bmdma_status,
 418         .qc_prep                = ata_qc_prep,
 419         .qc_issue               = ata_qc_issue_prot,
 420         .freeze                 = nv_ck804_freeze,
 421         .thaw                   = nv_ck804_thaw,
 422         .error_handler          = nv_error_handler,
 423         .post_internal_cmd      = ata_bmdma_post_internal_cmd,
 424         .data_xfer              = ata_data_xfer,
 425         .irq_handler            = nv_ck804_interrupt,
 426         .irq_clear              = ata_bmdma_irq_clear,
 427         .irq_on                 = ata_irq_on,
 428         .irq_ack                = ata_irq_ack,
 429         .scr_read               = nv_scr_read,
 430         .scr_write              = nv_scr_write,
 431         .port_start             = ata_port_start,
 432         .host_stop              = nv_ck804_host_stop,
 433 };
 434
 435 static const struct ata_port_operations nv_adma_ops = {
 436         .port_disable           = ata_port_disable,
 437         .tf_load                = ata_tf_load,
 438         .tf_read                = ata_tf_read,
 439         .check_atapi_dma        = nv_adma_check_atapi_dma,
 440         .exec_command           = ata_exec_command,
 441         .check_status           = ata_check_status,
 442         .dev_select             = ata_std_dev_select,
 443         .bmdma_setup            = ata_bmdma_setup,
 444         .bmdma_start            = ata_bmdma_start,
 445         .bmdma_stop             = ata_bmdma_stop,
 446         .bmdma_status           = ata_bmdma_status,
 447         .qc_prep                = nv_adma_qc_prep,
 448         .qc_issue               = nv_adma_qc_issue,
 449         .freeze                 = nv_ck804_freeze,
 450         .thaw                   = nv_ck804_thaw,
 451         .error_handler          = nv_adma_error_handler,
 452         .post_internal_cmd      = nv_adma_post_internal_cmd,
 453         .data_xfer              = ata_data_xfer,
 454         .irq_handler            = nv_adma_interrupt,
 455         .irq_clear              = nv_adma_irq_clear,
 456         .irq_on                 = ata_irq_on,
 457         .irq_ack                = ata_irq_ack,
 458         .scr_read               = nv_scr_read,
 459         .scr_write              = nv_scr_write,
 460         .port_start             = nv_adma_port_start,
 461         .port_stop              = nv_adma_port_stop,
 462 #ifdef CONFIG_PM
 463         .port_suspend           = nv_adma_port_suspend,
 464         .port_resume            = nv_adma_port_resume,
 465 #endif
 466         .host_stop              = nv_adma_host_stop,
 467 };
 468
 469 static struct ata_port_info nv_port_info[] = {
 470         /* generic */
 471         {
 472                 .sht            = &nv_sht,
 473                 .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
 474                                   ATA_FLAG_HRST_TO_RESUME,
 475                 .pio_mask       = NV_PIO_MASK,
 476                 .mwdma_mask     = NV_MWDMA_MASK,
 477                 .udma_mask      = NV_UDMA_MASK,
 478                 .port_ops       = &nv_generic_ops,
 479         },
 480         /* nforce2/3 */
 481         {
 482                 .sht            = &nv_sht,
 483                 .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
 484                                   ATA_FLAG_HRST_TO_RESUME,
 485                 .pio_mask       = NV_PIO_MASK,
 486                 .mwdma_mask     = NV_MWDMA_MASK,
 487                 .udma_mask      = NV_UDMA_MASK,
 488                 .port_ops       = &nv_nf2_ops,
 489         },
 490         /* ck804 */
 491         {
 492                 .sht            = &nv_sht,
 493                 .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
 494                                   ATA_FLAG_HRST_TO_RESUME,
 495                 .pio_mask       = NV_PIO_MASK,
 496                 .mwdma_mask     = NV_MWDMA_MASK,
 497                 .udma_mask      = NV_UDMA_MASK,
 498                 .port_ops       = &nv_ck804_ops,
 499         },
 500         /* ADMA */
 501         {
 502                 .sht            = &nv_adma_sht,
 503                 .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
 504                                   ATA_FLAG_HRST_TO_RESUME |
 505                                   ATA_FLAG_MMIO | ATA_FLAG_NCQ,
 506                 .pio_mask       = NV_PIO_MASK,
 507                 .mwdma_mask     = NV_MWDMA_MASK,
 508                 .udma_mask      = NV_UDMA_MASK,
 509                 .port_ops       = &nv_adma_ops,
 510         },
 511 };
 512
 513 MODULE_AUTHOR("NVIDIA");
 514 MODULE_DESCRIPTION("low-level driver for NVIDIA nForce SATA controller");
 515 MODULE_LICENSE("GPL");
 516 MODULE_DEVICE_TABLE(pci, nv_pci_tbl);
 517 MODULE_VERSION(DRV_VERSION);
 518
 519 static int adma_enabled = 1;
 520
 521 static void nv_adma_register_mode(struct ata_port *ap)
 522 {
 523         struct nv_adma_port_priv *pp = ap->private_data;
 524         void __iomem *mmio = pp->ctl_block;
 525         u16 tmp, status;
 526         int count = 0;
 527
 528         if (pp->flags & NV_ADMA_PORT_REGISTER_MODE)
 529                 return;
 530
 531         status = readw(mmio + NV_ADMA_STAT);
 532         while(!(status & NV_ADMA_STAT_IDLE) && count < 20) {
 533                 ndelay(50);
 534                 status = readw(mmio + NV_ADMA_STAT);
 535                 count++;
 536         }
 537         if(count == 20)
 538                 ata_port_printk(ap, KERN_WARNING,
 539                         "timeout waiting for ADMA IDLE, stat=0x%hx\n",
 540                         status);
 541
 542         tmp = readw(mmio + NV_ADMA_CTL);
 543         writew(tmp & ~NV_ADMA_CTL_GO, mmio + NV_ADMA_CTL);
 544
 545         count = 0;
 546         status = readw(mmio + NV_ADMA_STAT);
 547         while(!(status & NV_ADMA_STAT_LEGACY) && count < 20) {
 548                 ndelay(50);
 549                 status = readw(mmio + NV_ADMA_STAT);
 550                 count++;
 551         }
 552         if(count == 20)
 553                 ata_port_printk(ap, KERN_WARNING,
 554                          "timeout waiting for ADMA LEGACY, stat=0x%hx\n",
 555                          status);
 556
 557         pp->flags |= NV_ADMA_PORT_REGISTER_MODE;
 558 }
 559
 560 static void nv_adma_mode(struct ata_port *ap)
 561 {
 562         struct nv_adma_port_priv *pp = ap->private_data;
 563         void __iomem *mmio = pp->ctl_block;
 564         u16 tmp, status;
 565         int count = 0;
 566
 567         if (!(pp->flags & NV_ADMA_PORT_REGISTER_MODE))
 568                 return;
 569
 570         WARN_ON(pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE);
 571
 572         tmp = readw(mmio + NV_ADMA_CTL);
 573         writew(tmp | NV_ADMA_CTL_GO, mmio + NV_ADMA_CTL);
 574
 575         status = readw(mmio + NV_ADMA_STAT);
 576         while(((status & NV_ADMA_STAT_LEGACY) ||
 577               !(status & NV_ADMA_STAT_IDLE)) && count < 20) {
 578                 ndelay(50);
 579                 status = readw(mmio + NV_ADMA_STAT);
 580                 count++;
 581         }
 582         if(count == 20)
 583                 ata_port_printk(ap, KERN_WARNING,
 584                         "timeout waiting for ADMA LEGACY clear and IDLE, stat=0x%hx\n",
 585                         status);
 586
 587         pp->flags &= ~NV_ADMA_PORT_REGISTER_MODE;
 588 }
 589
 590 static int nv_adma_slave_config(struct scsi_device *sdev)
 591 {
 592         struct ata_port *ap = ata_shost_to_port(sdev->host);
 593         struct nv_adma_port_priv *pp = ap->private_data;
 594         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 595         u64 bounce_limit;
 596         unsigned long segment_boundary;
 597         unsigned short sg_tablesize;
 598         int rc;
 599         int adma_enable;
 600         u32 current_reg, new_reg, config_mask;
 601
 602         rc = ata_scsi_slave_config(sdev);
 603
 604         if (sdev->id >= ATA_MAX_DEVICES || sdev->channel || sdev->lun)
 605                 /* Not a proper libata device, ignore */
 606                 return rc;
 607
 608         if (ap->device[sdev->id].class == ATA_DEV_ATAPI) {
 609                 /*
 610                  * NVIDIA reports that ADMA mode does not support ATAPI commands.
 611                  * Therefore ATAPI commands are sent through the legacy interface.
 612                  * However, the legacy interface only supports 32-bit DMA.
 613                  * Restrict DMA parameters as required by the legacy interface
 614                  * when an ATAPI device is connected.
 615                  */
 616                 bounce_limit = ATA_DMA_MASK;
 617                 segment_boundary = ATA_DMA_BOUNDARY;
 618                 /* Subtract 1 since an extra entry may be needed for padding, see
 619                    libata-scsi.c */
 620                 sg_tablesize = LIBATA_MAX_PRD - 1;
 621
 622                 /* Since the legacy DMA engine is in use, we need to disable ADMA
 623                    on the port. */
 624                 adma_enable = 0;
 625                 nv_adma_register_mode(ap);
 626         }
 627         else {
 628                 bounce_limit = *ap->dev->dma_mask;
 629                 segment_boundary = NV_ADMA_DMA_BOUNDARY;
 630                 sg_tablesize = NV_ADMA_SGTBL_TOTAL_LEN;
 631                 adma_enable = 1;
 632         }
 633
 634         pci_read_config_dword(pdev, NV_MCP_SATA_CFG_20, &current_reg);
 635
 636         if(ap->port_no == 1)
 637                 config_mask = NV_MCP_SATA_CFG_20_PORT1_EN |
 638                               NV_MCP_SATA_CFG_20_PORT1_PWB_EN;
 639         else
 640                 config_mask = NV_MCP_SATA_CFG_20_PORT0_EN |
 641                               NV_MCP_SATA_CFG_20_PORT0_PWB_EN;
 642
 643         if(adma_enable) {
 644                 new_reg = current_reg | config_mask;
 645                 pp->flags &= ~NV_ADMA_ATAPI_SETUP_COMPLETE;
 646         }
 647         else {
 648                 new_reg = current_reg & ~config_mask;
 649                 pp->flags |= NV_ADMA_ATAPI_SETUP_COMPLETE;
 650         }
 651
 652         if(current_reg != new_reg)
 653                 pci_write_config_dword(pdev, NV_MCP_SATA_CFG_20, new_reg);
 654
 655         blk_queue_bounce_limit(sdev->request_queue, bounce_limit);
 656         blk_queue_segment_boundary(sdev->request_queue, segment_boundary);
 657         blk_queue_max_hw_segments(sdev->request_queue, sg_tablesize);
 658         ata_port_printk(ap, KERN_INFO,
 659                 "bounce limit 0x%llX, segment boundary 0x%lX, hw segs %hu\n",
 660                 (unsigned long long)bounce_limit, segment_boundary, sg_tablesize);
 661         return rc;
 662 }
 663
 664 static int nv_adma_check_atapi_dma(struct ata_queued_cmd *qc)
 665 {
 666         struct nv_adma_port_priv *pp = qc->ap->private_data;
 667         return !(pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE);
 668 }
 669
 670 static unsigned int nv_adma_tf_to_cpb(struct ata_taskfile *tf, __le16 *cpb)
 671 {
 672         unsigned int idx = 0;
 673
 674         if(tf->flags & ATA_TFLAG_ISADDR) {
 675                 if (tf->flags & ATA_TFLAG_LBA48) {
 676                         cpb[idx++] = cpu_to_le16((ATA_REG_ERR   << 8) | tf->hob_feature | WNB);
 677                         cpb[idx++] = cpu_to_le16((ATA_REG_NSECT << 8) | tf->hob_nsect);
 678                         cpb[idx++] = cpu_to_le16((ATA_REG_LBAL  << 8) | tf->hob_lbal);
 679                         cpb[idx++] = cpu_to_le16((ATA_REG_LBAM  << 8) | tf->hob_lbam);
 680                         cpb[idx++] = cpu_to_le16((ATA_REG_LBAH  << 8) | tf->hob_lbah);
 681                         cpb[idx++] = cpu_to_le16((ATA_REG_ERR    << 8) | tf->feature);
 682                 } else
 683                         cpb[idx++] = cpu_to_le16((ATA_REG_ERR    << 8) | tf->feature | WNB);
 684
 685                 cpb[idx++] = cpu_to_le16((ATA_REG_NSECT  << 8) | tf->nsect);
 686                 cpb[idx++] = cpu_to_le16((ATA_REG_LBAL   << 8) | tf->lbal);
 687                 cpb[idx++] = cpu_to_le16((ATA_REG_LBAM   << 8) | tf->lbam);
 688                 cpb[idx++] = cpu_to_le16((ATA_REG_LBAH   << 8) | tf->lbah);
 689         }
 690
 691         if(tf->flags & ATA_TFLAG_DEVICE)
 692                 cpb[idx++] = cpu_to_le16((ATA_REG_DEVICE << 8) | tf->device);
 693
 694         cpb[idx++] = cpu_to_le16((ATA_REG_CMD    << 8) | tf->command | CMDEND);
 695
 696         while(idx < 12)
 697                 cpb[idx++] = cpu_to_le16(IGN);
 698
 699         return idx;
 700 }
 701
 702 static int nv_adma_check_cpb(struct ata_port *ap, int cpb_num, int force_err)
 703 {
 704         struct nv_adma_port_priv *pp = ap->private_data;
 705         u8 flags = pp->cpb[cpb_num].resp_flags;
 706
 707         VPRINTK("CPB %d, flags=0x%x\n", cpb_num, flags);
 708
 709         if (unlikely((force_err ||
 710                      flags & (NV_CPB_RESP_ATA_ERR |
 711                               NV_CPB_RESP_CMD_ERR |
 712                               NV_CPB_RESP_CPB_ERR)))) {
 713                 struct ata_eh_info *ehi = &ap->eh_info;
 714                 int freeze = 0;
 715
 716                 ata_ehi_clear_desc(ehi);
 717                 ata_ehi_push_desc(ehi, "CPB resp_flags 0x%x", flags );
 718                 if (flags & NV_CPB_RESP_ATA_ERR) {
 719                         ata_ehi_push_desc(ehi, ": ATA error");
 720                         ehi->err_mask |= AC_ERR_DEV;
 721                 } else if (flags & NV_CPB_RESP_CMD_ERR) {
 722                         ata_ehi_push_desc(ehi, ": CMD error");
 723                         ehi->err_mask |= AC_ERR_DEV;
 724                 } else if (flags & NV_CPB_RESP_CPB_ERR) {
 725                         ata_ehi_push_desc(ehi, ": CPB error");
 726                         ehi->err_mask |= AC_ERR_SYSTEM;
 727                         freeze = 1;
 728                 } else {
 729                         /* notifier error, but no error in CPB flags? */
 730                         ehi->err_mask |= AC_ERR_OTHER;
 731                         freeze = 1;
 732                 }
 733                 /* Kill all commands. EH will determine what actually failed. */
 734                 if (freeze)
 735                         ata_port_freeze(ap);
 736                 else
 737                         ata_port_abort(ap);
 738                 return 1;
 739         }
 740
 741         if (flags & NV_CPB_RESP_DONE) {
 742                 struct ata_queued_cmd *qc = ata_qc_from_tag(ap, cpb_num);
 743                 VPRINTK("CPB flags done, flags=0x%x\n", flags);
 744                 if (likely(qc)) {
 745                         /* Grab the ATA port status for non-NCQ commands.
 746                            For NCQ commands the current status may have nothing to do with
 747                            the command just completed. */
 748                         if (qc->tf.protocol != ATA_PROT_NCQ) {
 749                                 u8 ata_status = readb(pp->ctl_block + (ATA_REG_STATUS * 4));
 750                                 qc->err_mask |= ac_err_mask(ata_status);
 751                         }
 752                         DPRINTK("Completing qc from tag %d with err_mask %u\n",cpb_num,
 753                                 qc->err_mask);
 754                         ata_qc_complete(qc);
 755                 } else {
 756                         struct ata_eh_info *ehi = &ap->eh_info;
 757                         /* Notifier bits set without a command may indicate the drive
 758                            is misbehaving. Raise host state machine violation on this
 759                            condition. */
 760                         ata_port_printk(ap, KERN_ERR, "notifier for tag %d with no command?\n",
 761                                 cpb_num);
 762                         ehi->err_mask |= AC_ERR_HSM;
 763                         ehi->action |= ATA_EH_SOFTRESET;
 764                         ata_port_freeze(ap);
 765                         return 1;
 766                 }
 767         }
 768         return 0;
 769 }
 770
 771 static int nv_host_intr(struct ata_port *ap, u8 irq_stat)
 772 {
 773         struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->active_tag);
 774
 775         /* freeze if hotplugged */
 776         if (unlikely(irq_stat & (NV_INT_ADDED | NV_INT_REMOVED))) {
 777                 ata_port_freeze(ap);
 778                 return 1;
 779         }
 780
 781         /* bail out if not our interrupt */
 782         if (!(irq_stat & NV_INT_DEV))
 783                 return 0;
 784
 785         /* DEV interrupt w/ no active qc? */
 786         if (unlikely(!qc || (qc->tf.flags & ATA_TFLAG_POLLING))) {
 787                 ata_check_status(ap);
 788                 return 1;
 789         }
 790
 791         /* handle interrupt */
 792         return ata_host_intr(ap, qc);
 793 }
 794
 795 static irqreturn_t nv_adma_interrupt(int irq, void *dev_instance)
 796 {
 797         struct ata_host *host = dev_instance;
 798         int i, handled = 0;
 799         u32 notifier_clears[2];
 800
 801         spin_lock(&host->lock);
 802
 803         for (i = 0; i < host->n_ports; i++) {
 804                 struct ata_port *ap = host->ports[i];
 805                 notifier_clears[i] = 0;
 806
 807                 if (ap && !(ap->flags & ATA_FLAG_DISABLED)) {
 808                         struct nv_adma_port_priv *pp = ap->private_data;
 809                         void __iomem *mmio = pp->ctl_block;
 810                         u16 status;
 811                         u32 gen_ctl;
 812                         u32 notifier, notifier_error;
 813
 814                         /* if in ATA register mode, use standard ata interrupt handler */
 815                         if (pp->flags & NV_ADMA_PORT_REGISTER_MODE) {
 816                                 u8 irq_stat = readb(host->iomap[NV_MMIO_BAR] + NV_INT_STATUS_CK804)
 817                                         >> (NV_INT_PORT_SHIFT * i);
 818                                 if(ata_tag_valid(ap->active_tag))
 819                                         /** NV_INT_DEV indication seems unreliable at times
 820                                             at least in ADMA mode. Force it on always when a
 821                                             command is active, to prevent losing interrupts. */
 822                                         irq_stat |= NV_INT_DEV;
 823                                 handled += nv_host_intr(ap, irq_stat);
 824                                 continue;
 825                         }
 826
 827                         notifier = readl(mmio + NV_ADMA_NOTIFIER);
 828                         notifier_error = readl(mmio + NV_ADMA_NOTIFIER_ERROR);
 829                         notifier_clears[i] = notifier | notifier_error;
 830
 831                         gen_ctl = readl(pp->gen_block + NV_ADMA_GEN_CTL);
 832
 833                         if( !NV_ADMA_CHECK_INTR(gen_ctl, ap->port_no) && !notifier &&
 834                             !notifier_error)
 835                                 /* Nothing to do */
 836                                 continue;
 837
 838                         status = readw(mmio + NV_ADMA_STAT);
 839
 840                         /* Clear status. Ensure the controller sees the clearing before we start
 841                            looking at any of the CPB statuses, so that any CPB completions after
 842                            this point in the handler will raise another interrupt. */
 843                         writew(status, mmio + NV_ADMA_STAT);
 844                         readw(mmio + NV_ADMA_STAT); /* flush posted write */
 845                         rmb();
 846
 847                         handled++; /* irq handled if we got here */
 848
 849                         /* freeze if hotplugged or controller error */
 850                         if (unlikely(status & (NV_ADMA_STAT_HOTPLUG |
 851                                                NV_ADMA_STAT_HOTUNPLUG |
 852                                                NV_ADMA_STAT_TIMEOUT |
 853                                                NV_ADMA_STAT_SERROR))) {
 854                                 struct ata_eh_info *ehi = &ap->eh_info;
 855
 856                                 ata_ehi_clear_desc(ehi);
 857                                 ata_ehi_push_desc(ehi, "ADMA status 0x%08x", status );
 858                                 if (status & NV_ADMA_STAT_TIMEOUT) {
 859                                         ehi->err_mask |= AC_ERR_SYSTEM;
 860                                         ata_ehi_push_desc(ehi, ": timeout");
 861                                 } else if (status & NV_ADMA_STAT_HOTPLUG) {
 862                                         ata_ehi_hotplugged(ehi);
 863                                         ata_ehi_push_desc(ehi, ": hotplug");
 864                                 } else if (status & NV_ADMA_STAT_HOTUNPLUG) {
 865                                         ata_ehi_hotplugged(ehi);
 866                                         ata_ehi_push_desc(ehi, ": hot unplug");
 867                                 } else if (status & NV_ADMA_STAT_SERROR) {
 868                                         /* let libata analyze SError and figure out the cause */
 869                                         ata_ehi_push_desc(ehi, ": SError");
 870                                 }
 871                                 ata_port_freeze(ap);
 872                                 continue;
 873                         }
 874
 875                         if (status & (NV_ADMA_STAT_DONE |
 876                                       NV_ADMA_STAT_CPBERR)) {
 877                                 u32 check_commands;
 878                                 int pos, error = 0;
 879
 880                                 if(ata_tag_valid(ap->active_tag))
 881                                         check_commands = 1 << ap->active_tag;
 882                                 else
 883                                         check_commands = ap->sactive;
 884
 885                                 /** Check CPBs for completed commands */
 886                                 while ((pos = ffs(check_commands)) && !error) {
 887                                         pos--;
 888                                         error = nv_adma_check_cpb(ap, pos,
 889                                                 notifier_error & (1 << pos) );
 890                                         check_commands &= ~(1 << pos );
 891                                 }
 892                         }
 893                 }
 894         }
 895
 896         if(notifier_clears[0] || notifier_clears[1]) {
 897                 /* Note: Both notifier clear registers must be written
 898                    if either is set, even if one is zero, according to NVIDIA. */
 899                 struct nv_adma_port_priv *pp = host->ports[0]->private_data;
 900                 writel(notifier_clears[0], pp->notifier_clear_block);
 901                 pp = host->ports[1]->private_data;
 902                 writel(notifier_clears[1], pp->notifier_clear_block);
 903         }
 904
 905         spin_unlock(&host->lock);
 906
 907         return IRQ_RETVAL(handled);
 908 }
 909
 910 static void nv_adma_irq_clear(struct ata_port *ap)
 911 {
 912         struct nv_adma_port_priv *pp = ap->private_data;
 913         void __iomem *mmio = pp->ctl_block;
 914         u16 status = readw(mmio + NV_ADMA_STAT);
 915         u32 notifier = readl(mmio + NV_ADMA_NOTIFIER);
 916         u32 notifier_error = readl(mmio + NV_ADMA_NOTIFIER_ERROR);
 917         void __iomem *dma_stat_addr = ap->ioaddr.bmdma_addr + ATA_DMA_STATUS;
 918
 919         /* clear ADMA status */
 920         writew(status, mmio + NV_ADMA_STAT);
 921         writel(notifier | notifier_error,
 922                pp->notifier_clear_block);
 923
 924         /** clear legacy status */
 925         iowrite8(ioread8(dma_stat_addr), dma_stat_addr);
 926 }
 927
 928 static void nv_adma_post_internal_cmd(struct ata_queued_cmd *qc)
 929 {
 930         struct nv_adma_port_priv *pp = qc->ap->private_data;
 931
 932         if(pp->flags & NV_ADMA_PORT_REGISTER_MODE)
 933                 ata_bmdma_post_internal_cmd(qc);
 934 }
 935
 936 static int nv_adma_port_start(struct ata_port *ap)
 937 {
 938         struct device *dev = ap->host->dev;
 939         struct nv_adma_port_priv *pp;
 940         int rc;
 941         void *mem;
 942         dma_addr_t mem_dma;
 943         void __iomem *mmio;
 944         u16 tmp;
 945
 946         VPRINTK("ENTER\n");
 947
 948         rc = ata_port_start(ap);
 949         if (rc)
 950                 return rc;
 951
 952         pp = devm_kzalloc(dev, sizeof(*pp), GFP_KERNEL);
 953         if (!pp)
 954                 return -ENOMEM;
 955
 956         mmio = ap->host->iomap[NV_MMIO_BAR] + NV_ADMA_PORT +
 957                ap->port_no * NV_ADMA_PORT_SIZE;
 958         pp->ctl_block = mmio;
 959         pp->gen_block = ap->host->iomap[NV_MMIO_BAR] + NV_ADMA_GEN;
 960         pp->notifier_clear_block = pp->gen_block +
 961                NV_ADMA_NOTIFIER_CLEAR + (4 * ap->port_no);
 962
 963         mem = dmam_alloc_coherent(dev, NV_ADMA_PORT_PRIV_DMA_SZ,
 964                                   &mem_dma, GFP_KERNEL);
 965         if (!mem)
 966                 return -ENOMEM;
 967         memset(mem, 0, NV_ADMA_PORT_PRIV_DMA_SZ);
 968
 969         /*
 970          * First item in chunk of DMA memory:
 971          * 128-byte command parameter block (CPB)
 972          * one for each command tag
 973          */
 974         pp->cpb     = mem;
 975         pp->cpb_dma = mem_dma;
 976
 977         writel(mem_dma & 0xFFFFFFFF,    mmio + NV_ADMA_CPB_BASE_LOW);
 978         writel((mem_dma >> 16 ) >> 16,  mmio + NV_ADMA_CPB_BASE_HIGH);
 979
 980         mem     += NV_ADMA_MAX_CPBS * NV_ADMA_CPB_SZ;
 981         mem_dma += NV_ADMA_MAX_CPBS * NV_ADMA_CPB_SZ;
 982
 983         /*
 984          * Second item: block of ADMA_SGTBL_LEN s/g entries
 985          */
 986         pp->aprd = mem;
 987         pp->aprd_dma = mem_dma;
 988
 989         ap->private_data = pp;
 990
 991         /* clear any outstanding interrupt conditions */
 992         writew(0xffff, mmio + NV_ADMA_STAT);
 993
 994         /* initialize port variables */
 995         pp->flags = NV_ADMA_PORT_REGISTER_MODE;
 996
 997         /* clear CPB fetch count */
 998         writew(0, mmio + NV_ADMA_CPB_COUNT);
 999
1000         /* clear GO for register mode, enable interrupt */
1001         tmp = readw(mmio + NV_ADMA_CTL);
1002         writew( (tmp & ~NV_ADMA_CTL_GO) | NV_ADMA_CTL_AIEN |
1003                  NV_ADMA_CTL_HOTPLUG_IEN, mmio + NV_ADMA_CTL);
1004
1005         tmp = readw(mmio + NV_ADMA_CTL);
1006         writew(tmp | NV_ADMA_CTL_CHANNEL_RESET, mmio + NV_ADMA_CTL);
1007         readw( mmio + NV_ADMA_CTL );    /* flush posted write */
1008         udelay(1);
1009         writew(tmp & ~NV_ADMA_CTL_CHANNEL_RESET, mmio + NV_ADMA_CTL);
1010         readw( mmio + NV_ADMA_CTL );    /* flush posted write */
1011
1012         return 0;
1013 }
1014
1015 static void nv_adma_port_stop(struct ata_port *ap)
1016 {
1017         struct nv_adma_port_priv *pp = ap->private_data;
1018         void __iomem *mmio = pp->ctl_block;
1019
1020         VPRINTK("ENTER\n");
1021         writew(0, mmio + NV_ADMA_CTL);
1022 }
1023
1024 #ifdef CONFIG_PM
1025 static int nv_adma_port_suspend(struct ata_port *ap, pm_message_t mesg)
1026 {
1027         struct nv_adma_port_priv *pp = ap->private_data;
1028         void __iomem *mmio = pp->ctl_block;
1029
1030         /* Go to register mode - clears GO */
1031         nv_adma_register_mode(ap);
1032
1033         /* clear CPB fetch count */
1034         writew(0, mmio + NV_ADMA_CPB_COUNT);
1035
1036         /* disable interrupt, shut down port */
1037         writew(0, mmio + NV_ADMA_CTL);
1038
1039         return 0;
1040 }
1041
1042 static int nv_adma_port_resume(struct ata_port *ap)
1043 {
1044         struct nv_adma_port_priv *pp = ap->private_data;
1045         void __iomem *mmio = pp->ctl_block;
1046         u16 tmp;
1047
1048         /* set CPB block location */
1049         writel(pp->cpb_dma & 0xFFFFFFFF,        mmio + NV_ADMA_CPB_BASE_LOW);
1050         writel((pp->cpb_dma >> 16 ) >> 16,      mmio + NV_ADMA_CPB_BASE_HIGH);
1051
1052         /* clear any outstanding interrupt conditions */
1053         writew(0xffff, mmio + NV_ADMA_STAT);
1054
1055         /* initialize port variables */
1056         pp->flags |= NV_ADMA_PORT_REGISTER_MODE;
1057
1058         /* clear CPB fetch count */
1059         writew(0, mmio + NV_ADMA_CPB_COUNT);
1060
1061         /* clear GO for register mode, enable interrupt */
1062         tmp = readw(mmio + NV_ADMA_CTL);
1063         writew( (tmp & ~NV_ADMA_CTL_GO) | NV_ADMA_CTL_AIEN |
1064                  NV_ADMA_CTL_HOTPLUG_IEN, mmio + NV_ADMA_CTL);
1065
1066         tmp = readw(mmio + NV_ADMA_CTL);
1067         writew(tmp | NV_ADMA_CTL_CHANNEL_RESET, mmio + NV_ADMA_CTL);
1068         readw( mmio + NV_ADMA_CTL );    /* flush posted write */
1069         udelay(1);
1070         writew(tmp & ~NV_ADMA_CTL_CHANNEL_RESET, mmio + NV_ADMA_CTL);
1071         readw( mmio + NV_ADMA_CTL );    /* flush posted write */
1072
1073         return 0;
1074 }
1075 #endif
1076
1077 static void nv_adma_setup_port(struct ata_probe_ent *probe_ent, unsigned int port)
1078 {
1079         void __iomem *mmio = probe_ent->iomap[NV_MMIO_BAR];
1080         struct ata_ioports *ioport = &probe_ent->port[port];
1081
1082         VPRINTK("ENTER\n");
1083
1084         mmio += NV_ADMA_PORT + port * NV_ADMA_PORT_SIZE;
1085
1086         ioport->cmd_addr        = mmio;
1087         ioport->data_addr       = mmio + (ATA_REG_DATA * 4);
1088         ioport->error_addr      =
1089         ioport->feature_addr    = mmio + (ATA_REG_ERR * 4);
1090         ioport->nsect_addr      = mmio + (ATA_REG_NSECT * 4);
1091         ioport->lbal_addr       = mmio + (ATA_REG_LBAL * 4);
1092         ioport->lbam_addr       = mmio + (ATA_REG_LBAM * 4);
1093         ioport->lbah_addr       = mmio + (ATA_REG_LBAH * 4);
1094         ioport->device_addr     = mmio + (ATA_REG_DEVICE * 4);
1095         ioport->status_addr     =
1096         ioport->command_addr    = mmio + (ATA_REG_STATUS * 4);
1097         ioport->altstatus_addr  =
1098         ioport->ctl_addr        = mmio + 0x20;
1099 }
1100
1101 static int nv_adma_host_init(struct ata_probe_ent *probe_ent)
1102 {
1103         struct pci_dev *pdev = to_pci_dev(probe_ent->dev);
1104         unsigned int i;
1105         u32 tmp32;
1106
1107         VPRINTK("ENTER\n");
1108
1109         /* enable ADMA on the ports */
1110         pci_read_config_dword(pdev, NV_MCP_SATA_CFG_20, &tmp32);
1111         tmp32 |= NV_MCP_SATA_CFG_20_PORT0_EN |
1112                  NV_MCP_SATA_CFG_20_PORT0_PWB_EN |
1113                  NV_MCP_SATA_CFG_20_PORT1_EN |
1114                  NV_MCP_SATA_CFG_20_PORT1_PWB_EN;
1115
1116         pci_write_config_dword(pdev, NV_MCP_SATA_CFG_20, tmp32);
1117
1118         for (i = 0; i < probe_ent->n_ports; i++)
1119                 nv_adma_setup_port(probe_ent, i);
1120
1121         return 0;
1122 }
1123
1124 static void nv_adma_fill_aprd(struct ata_queued_cmd *qc,
1125                               struct scatterlist *sg,
1126                               int idx,
1127                               struct nv_adma_prd *aprd)
1128 {
1129         u8 flags = 0;
1130         if (qc->tf.flags & ATA_TFLAG_WRITE)
1131                 flags |= NV_APRD_WRITE;
1132         if (idx == qc->n_elem - 1)
1133                 flags |= NV_APRD_END;
1134         else if (idx != 4)
1135                 flags |= NV_APRD_CONT;
1136
1137         aprd->addr  = cpu_to_le64(((u64)sg_dma_address(sg)));
1138         aprd->len   = cpu_to_le32(((u32)sg_dma_len(sg))); /* len in bytes */
1139         aprd->flags = flags;
1140         aprd->packet_len = 0;
1141 }
1142
1143 static void nv_adma_fill_sg(struct ata_queued_cmd *qc, struct nv_adma_cpb *cpb)
1144 {
1145         struct nv_adma_port_priv *pp = qc->ap->private_data;
1146         unsigned int idx;
1147         struct nv_adma_prd *aprd;
1148         struct scatterlist *sg;
1149
1150         VPRINTK("ENTER\n");
1151
1152         idx = 0;
1153
1154         ata_for_each_sg(sg, qc) {
1155                 aprd = (idx < 5) ? &cpb->aprd[idx] : &pp->aprd[NV_ADMA_SGTBL_LEN * qc->tag + (idx-5)];
1156                 nv_adma_fill_aprd(qc, sg, idx, aprd);
1157                 idx++;
1158         }
1159         if (idx > 5)
1160                 cpb->next_aprd = cpu_to_le64(((u64)(pp->aprd_dma + NV_ADMA_SGTBL_SZ * qc->tag)));
1161         else
1162                 cpb->next_aprd = cpu_to_le64(0);
1163 }
1164
1165 static int nv_adma_use_reg_mode(struct ata_queued_cmd *qc)
1166 {
1167         struct nv_adma_port_priv *pp = qc->ap->private_data;
1168
1169         /* ADMA engine can only be used for non-ATAPI DMA commands,
1170            or interrupt-driven no-data commands. */
1171         if((pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE) ||
1172            (qc->tf.flags & ATA_TFLAG_POLLING))
1173                 return 1;
1174
1175         if((qc->flags & ATA_QCFLAG_DMAMAP) ||
1176            (qc->tf.protocol == ATA_PROT_NODATA))
1177                 return 0;
1178
1179         return 1;
1180 }
1181
1182 static void nv_adma_qc_prep(struct ata_queued_cmd *qc)
1183 {
1184         struct nv_adma_port_priv *pp = qc->ap->private_data;
1185         struct nv_adma_cpb *cpb = &pp->cpb[qc->tag];
1186         u8 ctl_flags = NV_CPB_CTL_CPB_VALID |
1187                        NV_CPB_CTL_IEN;
1188
1189         if (nv_adma_use_reg_mode(qc)) {
1190                 nv_adma_register_mode(qc->ap);
1191                 ata_qc_prep(qc);
1192                 return;
1193         }
1194
1195         cpb->resp_flags = NV_CPB_RESP_DONE;
1196         wmb();
1197         cpb->ctl_flags = 0;
1198         wmb();
1199
1200         cpb->len                = 3;
1201         cpb->tag                = qc->tag;
1202         cpb->next_cpb_idx       = 0;
1203
1204         /* turn on NCQ flags for NCQ commands */
1205         if (qc->tf.protocol == ATA_PROT_NCQ)
1206                 ctl_flags |= NV_CPB_CTL_QUEUE | NV_CPB_CTL_FPDMA;
1207
1208         VPRINTK("qc->flags = 0x%lx\n", qc->flags);
1209
1210         nv_adma_tf_to_cpb(&qc->tf, cpb->tf);
1211
1212         if(qc->flags & ATA_QCFLAG_DMAMAP) {
1213                 nv_adma_fill_sg(qc, cpb);
1214                 ctl_flags |= NV_CPB_CTL_APRD_VALID;
1215         } else
1216                 memset(&cpb->aprd[0], 0, sizeof(struct nv_adma_prd) * 5);
1217
1218         /* Be paranoid and don't let the device see NV_CPB_CTL_CPB_VALID until we are
1219            finished filling in all of the contents */
1220         wmb();
1221         cpb->ctl_flags = ctl_flags;
1222         wmb();
1223         cpb->resp_flags = 0;
1224 }
1225
1226 static unsigned int nv_adma_qc_issue(struct ata_queued_cmd *qc)
1227 {
1228         struct nv_adma_port_priv *pp = qc->ap->private_data;
1229         void __iomem *mmio = pp->ctl_block;
1230         int curr_ncq = (qc->tf.protocol == ATA_PROT_NCQ);
1231
1232         VPRINTK("ENTER\n");
1233
1234         if (nv_adma_use_reg_mode(qc)) {
1235                 /* use ATA register mode */
1236                 VPRINTK("using ATA register mode: 0x%lx\n", qc->flags);
1237                 nv_adma_register_mode(qc->ap);
1238                 return ata_qc_issue_prot(qc);
1239         } else
1240                 nv_adma_mode(qc->ap);
1241
1242         /* write append register, command tag in lower 8 bits
1243            and (number of cpbs to append -1) in top 8 bits */
1244         wmb();
1245
1246         if(curr_ncq != pp->last_issue_ncq) {
1247                 /* Seems to need some delay before switching between NCQ and non-NCQ
1248                    commands, else we get command timeouts and such. */
1249                 udelay(20);
1250                 pp->last_issue_ncq = curr_ncq;
1251         }
1252
1253         writew(qc->tag, mmio + NV_ADMA_APPEND);
1254
1255         DPRINTK("Issued tag %u\n",qc->tag);
1256
1257         return 0;
1258 }
1259
1260 static irqreturn_t nv_generic_interrupt(int irq, void *dev_instance)
1261 {
1262         struct ata_host *host = dev_instance;
1263         unsigned int i;
1264         unsigned int handled = 0;
1265         unsigned long flags;
1266
1267         spin_lock_irqsave(&host->lock, flags);
1268
1269         for (i = 0; i < host->n_ports; i++) {
1270                 struct ata_port *ap;
1271
1272                 ap = host->ports[i];
1273                 if (ap &&
1274                     !(ap->flags & ATA_FLAG_DISABLED)) {
1275                         struct ata_queued_cmd *qc;
1276
1277                         qc = ata_qc_from_tag(ap, ap->active_tag);
1278                         if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)))
1279                                 handled += ata_host_intr(ap, qc);
1280                         else
1281                                 // No request pending?  Clear interrupt status
1282                                 // anyway, in case there's one pending.
1283                                 ap->ops->check_status(ap);
1284                 }
1285
1286         }
1287
1288         spin_unlock_irqrestore(&host->lock, flags);
1289
1290         return IRQ_RETVAL(handled);
1291 }
1292
1293 static irqreturn_t nv_do_interrupt(struct ata_host *host, u8 irq_stat)
1294 {
1295         int i, handled = 0;
1296
1297         for (i = 0; i < host->n_ports; i++) {
1298                 struct ata_port *ap = host->ports[i];
1299
1300                 if (ap && !(ap->flags & ATA_FLAG_DISABLED))
1301                         handled += nv_host_intr(ap, irq_stat);
1302
1303                 irq_stat >>= NV_INT_PORT_SHIFT;
1304         }
1305
1306         return IRQ_RETVAL(handled);
1307 }
1308
1309 static irqreturn_t nv_nf2_interrupt(int irq, void *dev_instance)
1310 {
1311         struct ata_host *host = dev_instance;
1312         u8 irq_stat;
1313         irqreturn_t ret;
1314
1315         spin_lock(&host->lock);
1316         irq_stat = ioread8(host->ports[0]->ioaddr.scr_addr + NV_INT_STATUS);
1317         ret = nv_do_interrupt(host, irq_stat);
1318         spin_unlock(&host->lock);
1319
1320         return ret;
1321 }
1322
1323 static irqreturn_t nv_ck804_interrupt(int irq, void *dev_instance)
1324 {
1325         struct ata_host *host = dev_instance;
1326         u8 irq_stat;
1327         irqreturn_t ret;
1328
1329         spin_lock(&host->lock);
1330         irq_stat = readb(host->iomap[NV_MMIO_BAR] + NV_INT_STATUS_CK804);
1331         ret = nv_do_interrupt(host, irq_stat);
1332         spin_unlock(&host->lock);
1333
1334         return ret;
1335 }
1336
1337 static u32 nv_scr_read (struct ata_port *ap, unsigned int sc_reg)
1338 {
1339         if (sc_reg > SCR_CONTROL)
1340                 return 0xffffffffU;
1341
1342         return ioread32(ap->ioaddr.scr_addr + (sc_reg * 4));
1343 }
1344
1345 static void nv_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val)
1346 {
1347         if (sc_reg > SCR_CONTROL)
1348                 return;
1349
1350         iowrite32(val, ap->ioaddr.scr_addr + (sc_reg * 4));
1351 }
1352
1353 static void nv_nf2_freeze(struct ata_port *ap)
1354 {
1355         void __iomem *scr_addr = ap->host->ports[0]->ioaddr.scr_addr;
1356         int shift = ap->port_no * NV_INT_PORT_SHIFT;
1357         u8 mask;
1358
1359         mask = ioread8(scr_addr + NV_INT_ENABLE);
1360         mask &= ~(NV_INT_ALL << shift);
1361         iowrite8(mask, scr_addr + NV_INT_ENABLE);
1362 }
1363
1364 static void nv_nf2_thaw(struct ata_port *ap)
1365 {
1366         void __iomem *scr_addr = ap->host->ports[0]->ioaddr.scr_addr;
1367         int shift = ap->port_no * NV_INT_PORT_SHIFT;
1368         u8 mask;
1369
1370         iowrite8(NV_INT_ALL << shift, scr_addr + NV_INT_STATUS);
1371
1372         mask = ioread8(scr_addr + NV_INT_ENABLE);
1373         mask |= (NV_INT_MASK << shift);
1374         iowrite8(mask, scr_addr + NV_INT_ENABLE);
1375 }
1376
1377 static void nv_ck804_freeze(struct ata_port *ap)
1378 {
1379         void __iomem *mmio_base = ap->host->iomap[NV_MMIO_BAR];
1380         int shift = ap->port_no * NV_INT_PORT_SHIFT;
1381         u8 mask;
1382
1383         mask = readb(mmio_base + NV_INT_ENABLE_CK804);
1384         mask &= ~(NV_INT_ALL << shift);
1385         writeb(mask, mmio_base + NV_INT_ENABLE_CK804);
1386 }
1387
1388 static void nv_ck804_thaw(struct ata_port *ap)
1389 {
1390         void __iomem *mmio_base = ap->host->iomap[NV_MMIO_BAR];
1391         int shift = ap->port_no * NV_INT_PORT_SHIFT;
1392         u8 mask;
1393
1394         writeb(NV_INT_ALL << shift, mmio_base + NV_INT_STATUS_CK804);
1395
1396         mask = readb(mmio_base + NV_INT_ENABLE_CK804);
1397         mask |= (NV_INT_MASK << shift);
1398         writeb(mask, mmio_base + NV_INT_ENABLE_CK804);
1399 }
1400
1401 static int nv_hardreset(struct ata_port *ap, unsigned int *class)
1402 {
1403         unsigned int dummy;
1404
1405         /* SATA hardreset fails to retrieve proper device signature on
1406          * some controllers.  Don't classify on hardreset.  For more
1407          * info, see http://bugme.osdl.org/show_bug.cgi?id=3352
1408          */
1409         return sata_std_hardreset(ap, &dummy);
1410 }
1411
1412 static void nv_error_handler(struct ata_port *ap)
1413 {
1414         ata_bmdma_drive_eh(ap, ata_std_prereset, ata_std_softreset,
1415                            nv_hardreset, ata_std_postreset);
1416 }
1417
1418 static void nv_adma_error_handler(struct ata_port *ap)
1419 {
1420         struct nv_adma_port_priv *pp = ap->private_data;
1421         if(!(pp->flags & NV_ADMA_PORT_REGISTER_MODE)) {
1422                 void __iomem *mmio = pp->ctl_block;
1423                 int i;
1424                 u16 tmp;
1425
1426                 if(ata_tag_valid(ap->active_tag) || ap->sactive) {
1427                         u32 notifier = readl(mmio + NV_ADMA_NOTIFIER);
1428                         u32 notifier_error = readl(mmio + NV_ADMA_NOTIFIER_ERROR);
1429                         u32 gen_ctl = readl(pp->gen_block + NV_ADMA_GEN_CTL);
1430                         u32 status = readw(mmio + NV_ADMA_STAT);
1431                         u8 cpb_count = readb(mmio + NV_ADMA_CPB_COUNT);
1432                         u8 next_cpb_idx = readb(mmio + NV_ADMA_NEXT_CPB_IDX);
1433
1434                         ata_port_printk(ap, KERN_ERR, "EH in ADMA mode, notifier 0x%X "
1435                                 "notifier_error 0x%X gen_ctl 0x%X status 0x%X "
1436                                 "next cpb count 0x%X next cpb idx 0x%x\n",
1437                                 notifier, notifier_error, gen_ctl, status,
1438                                 cpb_count, next_cpb_idx);
1439
1440                         for( i=0;i<NV_ADMA_MAX_CPBS;i++) {
1441                                 struct nv_adma_cpb *cpb = &pp->cpb[i];
1442                                 if( (ata_tag_valid(ap->active_tag) && i == ap->active_tag) ||
1443                                     ap->sactive & (1 << i) )
1444                                         ata_port_printk(ap, KERN_ERR,
1445                                                 "CPB %d: ctl_flags 0x%x, resp_flags 0x%x\n",
1446                                                 i, cpb->ctl_flags, cpb->resp_flags);
1447                         }
1448                 }
1449
1450                 /* Push us back into port register mode for error handling. */
1451                 nv_adma_register_mode(ap);
1452
1453                 /* Mark all of the CPBs as invalid to prevent them from being executed */
1454                 for( i=0;i<NV_ADMA_MAX_CPBS;i++)
1455                         pp->cpb[i].ctl_flags &= ~NV_CPB_CTL_CPB_VALID;
1456
1457                 /* clear CPB fetch count */
1458                 writew(0, mmio + NV_ADMA_CPB_COUNT);
1459
1460                 /* Reset channel */
1461                 tmp = readw(mmio + NV_ADMA_CTL);
1462                 writew(tmp | NV_ADMA_CTL_CHANNEL_RESET, mmio + NV_ADMA_CTL);
1463                 readw( mmio + NV_ADMA_CTL );    /* flush posted write */
1464                 udelay(1);
1465                 writew(tmp & ~NV_ADMA_CTL_CHANNEL_RESET, mmio + NV_ADMA_CTL);
1466                 readw( mmio + NV_ADMA_CTL );    /* flush posted write */
1467         }
1468
1469         ata_bmdma_drive_eh(ap, ata_std_prereset, ata_std_softreset,
1470                            nv_hardreset, ata_std_postreset);
1471 }
1472
1473 static int nv_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
1474 {
1475         static int printed_version = 0;
1476         struct ata_port_info *ppi[2];
1477         struct ata_probe_ent *probe_ent;
1478         struct nv_host_priv *hpriv;
1479         int rc;
1480         u32 bar;
1481         void __iomem *base;
1482         unsigned long type = ent->driver_data;
1483         int mask_set = 0;
1484
1485         // Make sure this is a SATA controller by counting the number of bars
1486         // (NVIDIA SATA controllers will always have six bars).  Otherwise,
1487         // it's an IDE controller and we ignore it.
1488         for (bar=0; bar<6; bar++)
1489                 if (pci_resource_start(pdev, bar) == 0)
1490                         return -ENODEV;
1491
1492         if (!printed_version++)
1493                 dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
1494
1495         rc = pcim_enable_device(pdev);
1496         if (rc)
1497                 return rc;
1498
1499         rc = pci_request_regions(pdev, DRV_NAME);
1500         if (rc) {
1501                 pcim_pin_device(pdev);
1502                 return rc;
1503         }
1504
1505         if(type >= CK804 && adma_enabled) {
1506                 dev_printk(KERN_NOTICE, &pdev->dev, "Using ADMA mode\n");
1507                 type = ADMA;
1508                 if(!pci_set_dma_mask(pdev, DMA_64BIT_MASK) &&
1509                    !pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK))
1510                         mask_set = 1;
1511         }
1512
1513         if(!mask_set) {
1514                 rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
1515                 if (rc)
1516                         return rc;
1517                 rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
1518                 if (rc)
1519                         return rc;
1520         }
1521
1522         rc = -ENOMEM;
1523
1524         hpriv = devm_kzalloc(&pdev->dev, sizeof(*hpriv), GFP_KERNEL);
1525         if (!hpriv)
1526                 return -ENOMEM;
1527
1528         ppi[0] = ppi[1] = &nv_port_info[type];
1529         probe_ent = ata_pci_init_native_mode(pdev, ppi, ATA_PORT_PRIMARY | ATA_PORT_SECONDARY);
1530         if (!probe_ent)
1531                 return -ENOMEM;
1532
1533         if (!pcim_iomap(pdev, NV_MMIO_BAR, 0))
1534                 return -EIO;
1535         probe_ent->iomap = pcim_iomap_table(pdev);
1536
1537         probe_ent->private_data = hpriv;
1538         hpriv->type = type;
1539
1540         base = probe_ent->iomap[NV_MMIO_BAR];
1541         probe_ent->port[0].scr_addr = base + NV_PORT0_SCR_REG_OFFSET;
1542         probe_ent->port[1].scr_addr = base + NV_PORT1_SCR_REG_OFFSET;
1543
1544         /* enable SATA space for CK804 */
1545         if (type >= CK804) {
1546                 u8 regval;
1547
1548                 pci_read_config_byte(pdev, NV_MCP_SATA_CFG_20, &regval);
1549                 regval |= NV_MCP_SATA_CFG_20_SATA_SPACE_EN;
1550                 pci_write_config_byte(pdev, NV_MCP_SATA_CFG_20, regval);
1551         }
1552
1553         pci_set_master(pdev);
1554
1555         if (type == ADMA) {
1556                 rc = nv_adma_host_init(probe_ent);
1557                 if (rc)
1558                         return rc;
1559         }
1560
1561         rc = ata_device_add(probe_ent);
1562         if (rc != NV_PORTS)
1563                 return -ENODEV;
1564
1565         devm_kfree(&pdev->dev, probe_ent);
1566         return 0;
1567 }
1568
1569 static void nv_remove_one (struct pci_dev *pdev)
1570 {
1571         struct ata_host *host = dev_get_drvdata(&pdev->dev);
1572         struct nv_host_priv *hpriv = host->private_data;
1573
1574         ata_pci_remove_one(pdev);
1575         kfree(hpriv);
1576 }
1577
1578 #ifdef CONFIG_PM
1579 static int nv_pci_device_resume(struct pci_dev *pdev)
1580 {
1581         struct ata_host *host = dev_get_drvdata(&pdev->dev);
1582         struct nv_host_priv *hpriv = host->private_data;
1583         int rc;
1584
1585         rc = ata_pci_device_do_resume(pdev);
1586         if(rc)
1587                 return rc;
1588
1589         if (pdev->dev.power.power_state.event == PM_EVENT_SUSPEND) {
1590                 if(hpriv->type >= CK804) {
1591                         u8 regval;
1592
1593                         pci_read_config_byte(pdev, NV_MCP_SATA_CFG_20, &regval);
1594                         regval |= NV_MCP_SATA_CFG_20_SATA_SPACE_EN;
1595                         pci_write_config_byte(pdev, NV_MCP_SATA_CFG_20, regval);
1596                 }
1597                 if(hpriv->type == ADMA) {
1598                         u32 tmp32;
1599                         struct nv_adma_port_priv *pp;
1600                         /* enable/disable ADMA on the ports appropriately */
1601                         pci_read_config_dword(pdev, NV_MCP_SATA_CFG_20, &tmp32);
1602
1603                         pp = host->ports[0]->private_data;
1604                         if(pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE)
1605                                 tmp32 &= ~(NV_MCP_SATA_CFG_20_PORT0_EN |
1606                                            NV_MCP_SATA_CFG_20_PORT0_PWB_EN);
1607                         else
1608                                 tmp32 |=  (NV_MCP_SATA_CFG_20_PORT0_EN |
1609                                            NV_MCP_SATA_CFG_20_PORT0_PWB_EN);
1610                         pp = host->ports[1]->private_data;
1611                         if(pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE)
1612                                 tmp32 &= ~(NV_MCP_SATA_CFG_20_PORT1_EN |
1613                                            NV_MCP_SATA_CFG_20_PORT1_PWB_EN);
1614                         else
1615                                 tmp32 |=  (NV_MCP_SATA_CFG_20_PORT1_EN |
1616                                            NV_MCP_SATA_CFG_20_PORT1_PWB_EN);
1617
1618                         pci_write_config_dword(pdev, NV_MCP_SATA_CFG_20, tmp32);
1619                 }
1620         }
1621
1622         ata_host_resume(host);
1623
1624         return 0;
1625 }
1626 #endif
1627
1628 static void nv_ck804_host_stop(struct ata_host *host)
1629 {
1630         struct pci_dev *pdev = to_pci_dev(host->dev);
1631         u8 regval;
1632
1633         /* disable SATA space for CK804 */
1634         pci_read_config_byte(pdev, NV_MCP_SATA_CFG_20, &regval);
1635         regval &= ~NV_MCP_SATA_CFG_20_SATA_SPACE_EN;
1636         pci_write_config_byte(pdev, NV_MCP_SATA_CFG_20, regval);
1637 }
1638
1639 static void nv_adma_host_stop(struct ata_host *host)
1640 {
1641         struct pci_dev *pdev = to_pci_dev(host->dev);
1642         u32 tmp32;
1643
1644         /* disable ADMA on the ports */
1645         pci_read_config_dword(pdev, NV_MCP_SATA_CFG_20, &tmp32);
1646         tmp32 &= ~(NV_MCP_SATA_CFG_20_PORT0_EN |
1647                    NV_MCP_SATA_CFG_20_PORT0_PWB_EN |
1648                    NV_MCP_SATA_CFG_20_PORT1_EN |
1649                    NV_MCP_SATA_CFG_20_PORT1_PWB_EN);
1650
1651         pci_write_config_dword(pdev, NV_MCP_SATA_CFG_20, tmp32);
1652
1653         nv_ck804_host_stop(host);
1654 }
1655
1656 static int __init nv_init(void)
1657 {
1658         return pci_register_driver(&nv_pci_driver);
1659 }
1660
1661 static void __exit nv_exit(void)
1662 {
1663         pci_unregister_driver(&nv_pci_driver);
1664 }
1665
1666 module_init(nv_init);
1667 module_exit(nv_exit);
1668 module_param_named(adma, adma_enabled, bool, 0444);
1669 MODULE_PARM_DESC(adma, "Enable use of ADMA (Default: true)");