err.no Git - linux-2.6/blob - drivers/ata/sata_mv.c

   1 /*
   2  * sata_mv.c - Marvell SATA support
   3  *
   4  * Copyright 2005: EMC Corporation, all rights reserved.
   5  * Copyright 2005 Red Hat, Inc.  All rights reserved.
   6  *
   7  * Please ALWAYS copy linux-ide@vger.kernel.org on emails.
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; version 2 of the License.
  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; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  *
  22  */
  23
  24 /*
  25   sata_mv TODO list:
  26
  27   1) Needs a full errata audit for all chipsets.  I implemented most
  28   of the errata workarounds found in the Marvell vendor driver, but
  29   I distinctly remember a couple workarounds (one related to PCI-X)
  30   are still needed.
  31
  32   4) Add NCQ support (easy to intermediate, once new-EH support appears)
  33
  34   5) Investigate problems with PCI Message Signalled Interrupts (MSI).
  35
  36   6) Add port multiplier support (intermediate)
  37
  38   8) Develop a low-power-consumption strategy, and implement it.
  39
  40   9) [Experiment, low priority] See if ATAPI can be supported using
  41   "unknown FIS" or "vendor-specific FIS" support, or something creative
  42   like that.
  43
  44   10) [Experiment, low priority] Investigate interrupt coalescing.
  45   Quite often, especially with PCI Message Signalled Interrupts (MSI),
  46   the overhead reduced by interrupt mitigation is quite often not
  47   worth the latency cost.
  48
  49   11) [Experiment, Marvell value added] Is it possible to use target
  50   mode to cross-connect two Linux boxes with Marvell cards?  If so,
  51   creating LibATA target mode support would be very interesting.
  52
  53   Target mode, for those without docs, is the ability to directly
  54   connect two SATA controllers.
  55
  56   13) Verify that 7042 is fully supported.  I only have a 6042.
  57
  58 */
  59
  60
  61 #include <linux/kernel.h>
  62 #include <linux/module.h>
  63 #include <linux/pci.h>
  64 #include <linux/init.h>
  65 #include <linux/blkdev.h>
  66 #include <linux/delay.h>
  67 #include <linux/interrupt.h>
  68 #include <linux/dma-mapping.h>
  69 #include <linux/device.h>
  70 #include <scsi/scsi_host.h>
  71 #include <scsi/scsi_cmnd.h>
  72 #include <scsi/scsi_device.h>
  73 #include <linux/libata.h>
  74
  75 #define DRV_NAME        "sata_mv"
  76 #define DRV_VERSION     "1.01"
  77
  78 enum {
  79         /* BAR's are enumerated in terms of pci_resource_start() terms */
  80         MV_PRIMARY_BAR          = 0,    /* offset 0x10: memory space */
  81         MV_IO_BAR               = 2,    /* offset 0x18: IO space */
  82         MV_MISC_BAR             = 3,    /* offset 0x1c: FLASH, NVRAM, SRAM */
  83
  84         MV_MAJOR_REG_AREA_SZ    = 0x10000,      /* 64KB */
  85         MV_MINOR_REG_AREA_SZ    = 0x2000,       /* 8KB */
  86
  87         MV_PCI_REG_BASE         = 0,
  88         MV_IRQ_COAL_REG_BASE    = 0x18000,      /* 6xxx part only */
  89         MV_IRQ_COAL_CAUSE               = (MV_IRQ_COAL_REG_BASE + 0x08),
  90         MV_IRQ_COAL_CAUSE_LO            = (MV_IRQ_COAL_REG_BASE + 0x88),
  91         MV_IRQ_COAL_CAUSE_HI            = (MV_IRQ_COAL_REG_BASE + 0x8c),
  92         MV_IRQ_COAL_THRESHOLD           = (MV_IRQ_COAL_REG_BASE + 0xcc),
  93         MV_IRQ_COAL_TIME_THRESHOLD      = (MV_IRQ_COAL_REG_BASE + 0xd0),
  94
  95         MV_SATAHC0_REG_BASE     = 0x20000,
  96         MV_FLASH_CTL            = 0x1046c,
  97         MV_GPIO_PORT_CTL        = 0x104f0,
  98         MV_RESET_CFG            = 0x180d8,
  99
 100         MV_PCI_REG_SZ           = MV_MAJOR_REG_AREA_SZ,
 101         MV_SATAHC_REG_SZ        = MV_MAJOR_REG_AREA_SZ,
 102         MV_SATAHC_ARBTR_REG_SZ  = MV_MINOR_REG_AREA_SZ,         /* arbiter */
 103         MV_PORT_REG_SZ          = MV_MINOR_REG_AREA_SZ,
 104
 105         MV_MAX_Q_DEPTH          = 32,
 106         MV_MAX_Q_DEPTH_MASK     = MV_MAX_Q_DEPTH - 1,
 107
 108         /* CRQB needs alignment on a 1KB boundary. Size == 1KB
 109          * CRPB needs alignment on a 256B boundary. Size == 256B
 110          * SG count of 176 leads to MV_PORT_PRIV_DMA_SZ == 4KB
 111          * ePRD (SG) entries need alignment on a 16B boundary. Size == 16B
 112          */
 113         MV_CRQB_Q_SZ            = (32 * MV_MAX_Q_DEPTH),
 114         MV_CRPB_Q_SZ            = (8 * MV_MAX_Q_DEPTH),
 115         MV_MAX_SG_CT            = 176,
 116         MV_SG_TBL_SZ            = (16 * MV_MAX_SG_CT),
 117         MV_PORT_PRIV_DMA_SZ     = (MV_CRQB_Q_SZ + MV_CRPB_Q_SZ + MV_SG_TBL_SZ),
 118
 119         MV_PORTS_PER_HC         = 4,
 120         /* == (port / MV_PORTS_PER_HC) to determine HC from 0-7 port */
 121         MV_PORT_HC_SHIFT        = 2,
 122         /* == (port % MV_PORTS_PER_HC) to determine hard port from 0-7 port */
 123         MV_PORT_MASK            = 3,
 124
 125         /* Host Flags */
 126         MV_FLAG_DUAL_HC         = (1 << 30),  /* two SATA Host Controllers */
 127         MV_FLAG_IRQ_COALESCE    = (1 << 29),  /* IRQ coalescing capability */
 128         MV_COMMON_FLAGS         = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
 129                                   ATA_FLAG_MMIO | ATA_FLAG_NO_ATAPI |
 130                                   ATA_FLAG_PIO_POLLING,
 131         MV_6XXX_FLAGS           = MV_FLAG_IRQ_COALESCE,
 132
 133         CRQB_FLAG_READ          = (1 << 0),
 134         CRQB_TAG_SHIFT          = 1,
 135         CRQB_IOID_SHIFT         = 6,    /* CRQB Gen-II/IIE IO Id shift */
 136         CRQB_HOSTQ_SHIFT        = 17,   /* CRQB Gen-II/IIE HostQueTag shift */
 137         CRQB_CMD_ADDR_SHIFT     = 8,
 138         CRQB_CMD_CS             = (0x2 << 11),
 139         CRQB_CMD_LAST           = (1 << 15),
 140
 141         CRPB_FLAG_STATUS_SHIFT  = 8,
 142         CRPB_IOID_SHIFT_6       = 5,    /* CRPB Gen-II IO Id shift */
 143         CRPB_IOID_SHIFT_7       = 7,    /* CRPB Gen-IIE IO Id shift */
 144
 145         EPRD_FLAG_END_OF_TBL    = (1 << 31),
 146
 147         /* PCI interface registers */
 148
 149         PCI_COMMAND_OFS         = 0xc00,
 150
 151         PCI_MAIN_CMD_STS_OFS    = 0xd30,
 152         STOP_PCI_MASTER         = (1 << 2),
 153         PCI_MASTER_EMPTY        = (1 << 3),
 154         GLOB_SFT_RST            = (1 << 4),
 155
 156         MV_PCI_MODE             = 0xd00,
 157         MV_PCI_EXP_ROM_BAR_CTL  = 0xd2c,
 158         MV_PCI_DISC_TIMER       = 0xd04,
 159         MV_PCI_MSI_TRIGGER      = 0xc38,
 160         MV_PCI_SERR_MASK        = 0xc28,
 161         MV_PCI_XBAR_TMOUT       = 0x1d04,
 162         MV_PCI_ERR_LOW_ADDRESS  = 0x1d40,
 163         MV_PCI_ERR_HIGH_ADDRESS = 0x1d44,
 164         MV_PCI_ERR_ATTRIBUTE    = 0x1d48,
 165         MV_PCI_ERR_COMMAND      = 0x1d50,
 166
 167         PCI_IRQ_CAUSE_OFS       = 0x1d58,
 168         PCI_IRQ_MASK_OFS        = 0x1d5c,
 169         PCI_UNMASK_ALL_IRQS     = 0x7fffff,     /* bits 22-0 */
 170
 171         PCIE_IRQ_CAUSE_OFS      = 0x1900,
 172         PCIE_IRQ_MASK_OFS       = 0x1910,
 173         PCIE_UNMASK_ALL_IRQS    = 0x40a,        /* assorted bits */
 174
 175         HC_MAIN_IRQ_CAUSE_OFS   = 0x1d60,
 176         HC_MAIN_IRQ_MASK_OFS    = 0x1d64,
 177         PORT0_ERR               = (1 << 0),     /* shift by port # */
 178         PORT0_DONE              = (1 << 1),     /* shift by port # */
 179         HC0_IRQ_PEND            = 0x1ff,        /* bits 0-8 = HC0's ports */
 180         HC_SHIFT                = 9,            /* bits 9-17 = HC1's ports */
 181         PCI_ERR                 = (1 << 18),
 182         TRAN_LO_DONE            = (1 << 19),    /* 6xxx: IRQ coalescing */
 183         TRAN_HI_DONE            = (1 << 20),    /* 6xxx: IRQ coalescing */
 184         PORTS_0_3_COAL_DONE     = (1 << 8),
 185         PORTS_4_7_COAL_DONE     = (1 << 17),
 186         PORTS_0_7_COAL_DONE     = (1 << 21),    /* 6xxx: IRQ coalescing */
 187         GPIO_INT                = (1 << 22),
 188         SELF_INT                = (1 << 23),
 189         TWSI_INT                = (1 << 24),
 190         HC_MAIN_RSVD            = (0x7f << 25), /* bits 31-25 */
 191         HC_MAIN_RSVD_5          = (0x1fff << 19), /* bits 31-19 */
 192         HC_MAIN_MASKED_IRQS     = (TRAN_LO_DONE | TRAN_HI_DONE |
 193                                    PORTS_0_7_COAL_DONE | GPIO_INT | TWSI_INT |
 194                                    HC_MAIN_RSVD),
 195         HC_MAIN_MASKED_IRQS_5   = (PORTS_0_3_COAL_DONE | PORTS_4_7_COAL_DONE |
 196                                    HC_MAIN_RSVD_5),
 197
 198         /* SATAHC registers */
 199         HC_CFG_OFS              = 0,
 200
 201         HC_IRQ_CAUSE_OFS        = 0x14,
 202         CRPB_DMA_DONE           = (1 << 0),     /* shift by port # */
 203         HC_IRQ_COAL             = (1 << 4),     /* IRQ coalescing */
 204         DEV_IRQ                 = (1 << 8),     /* shift by port # */
 205
 206         /* Shadow block registers */
 207         SHD_BLK_OFS             = 0x100,
 208         SHD_CTL_AST_OFS         = 0x20,         /* ofs from SHD_BLK_OFS */
 209
 210         /* SATA registers */
 211         SATA_STATUS_OFS         = 0x300,  /* ctrl, err regs follow status */
 212         SATA_ACTIVE_OFS         = 0x350,
 213         SATA_FIS_IRQ_CAUSE_OFS  = 0x364,
 214         PHY_MODE3               = 0x310,
 215         PHY_MODE4               = 0x314,
 216         PHY_MODE2               = 0x330,
 217         MV5_PHY_MODE            = 0x74,
 218         MV5_LT_MODE             = 0x30,
 219         MV5_PHY_CTL             = 0x0C,
 220         SATA_INTERFACE_CTL      = 0x050,
 221
 222         MV_M2_PREAMP_MASK       = 0x7e0,
 223
 224         /* Port registers */
 225         EDMA_CFG_OFS            = 0,
 226         EDMA_CFG_Q_DEPTH        = 0x1f,         /* max device queue depth */
 227         EDMA_CFG_NCQ            = (1 << 5),     /* for R/W FPDMA queued */
 228         EDMA_CFG_NCQ_GO_ON_ERR  = (1 << 14),    /* continue on error */
 229         EDMA_CFG_RD_BRST_EXT    = (1 << 11),    /* read burst 512B */
 230         EDMA_CFG_WR_BUFF_LEN    = (1 << 13),    /* write buffer 512B */
 231
 232         EDMA_ERR_IRQ_CAUSE_OFS  = 0x8,
 233         EDMA_ERR_IRQ_MASK_OFS   = 0xc,
 234         EDMA_ERR_D_PAR          = (1 << 0),     /* UDMA data parity err */
 235         EDMA_ERR_PRD_PAR        = (1 << 1),     /* UDMA PRD parity err */
 236         EDMA_ERR_DEV            = (1 << 2),     /* device error */
 237         EDMA_ERR_DEV_DCON       = (1 << 3),     /* device disconnect */
 238         EDMA_ERR_DEV_CON        = (1 << 4),     /* device connected */
 239         EDMA_ERR_SERR           = (1 << 5),     /* SError bits [WBDST] raised */
 240         EDMA_ERR_SELF_DIS       = (1 << 7),     /* Gen II/IIE self-disable */
 241         EDMA_ERR_SELF_DIS_5     = (1 << 8),     /* Gen I self-disable */
 242         EDMA_ERR_BIST_ASYNC     = (1 << 8),     /* BIST FIS or Async Notify */
 243         EDMA_ERR_TRANS_IRQ_7    = (1 << 8),     /* Gen IIE transprt layer irq */
 244         EDMA_ERR_CRQB_PAR       = (1 << 9),     /* CRQB parity error */
 245         EDMA_ERR_CRPB_PAR       = (1 << 10),    /* CRPB parity error */
 246         EDMA_ERR_INTRL_PAR      = (1 << 11),    /* internal parity error */
 247         EDMA_ERR_IORDY          = (1 << 12),    /* IORdy timeout */
 248
 249         EDMA_ERR_LNK_CTRL_RX    = (0xf << 13),  /* link ctrl rx error */
 250         EDMA_ERR_LNK_CTRL_RX_0  = (1 << 13),    /* transient: CRC err */
 251         EDMA_ERR_LNK_CTRL_RX_1  = (1 << 14),    /* transient: FIFO err */
 252         EDMA_ERR_LNK_CTRL_RX_2  = (1 << 15),    /* fatal: caught SYNC */
 253         EDMA_ERR_LNK_CTRL_RX_3  = (1 << 16),    /* transient: FIS rx err */
 254
 255         EDMA_ERR_LNK_DATA_RX    = (0xf << 17),  /* link data rx error */
 256
 257         EDMA_ERR_LNK_CTRL_TX    = (0x1f << 21), /* link ctrl tx error */
 258         EDMA_ERR_LNK_CTRL_TX_0  = (1 << 21),    /* transient: CRC err */
 259         EDMA_ERR_LNK_CTRL_TX_1  = (1 << 22),    /* transient: FIFO err */
 260         EDMA_ERR_LNK_CTRL_TX_2  = (1 << 23),    /* transient: caught SYNC */
 261         EDMA_ERR_LNK_CTRL_TX_3  = (1 << 24),    /* transient: caught DMAT */
 262         EDMA_ERR_LNK_CTRL_TX_4  = (1 << 25),    /* transient: FIS collision */
 263
 264         EDMA_ERR_LNK_DATA_TX    = (0x1f << 26), /* link data tx error */
 265
 266         EDMA_ERR_TRANS_PROTO    = (1 << 31),    /* transport protocol error */
 267         EDMA_ERR_OVERRUN_5      = (1 << 5),
 268         EDMA_ERR_UNDERRUN_5     = (1 << 6),
 269
 270         EDMA_ERR_IRQ_TRANSIENT  = EDMA_ERR_LNK_CTRL_RX_0 |
 271                                   EDMA_ERR_LNK_CTRL_RX_1 |
 272                                   EDMA_ERR_LNK_CTRL_RX_3 |
 273                                   EDMA_ERR_LNK_CTRL_TX,
 274
 275         EDMA_EH_FREEZE          = EDMA_ERR_D_PAR |
 276                                   EDMA_ERR_PRD_PAR |
 277                                   EDMA_ERR_DEV_DCON |
 278                                   EDMA_ERR_DEV_CON |
 279                                   EDMA_ERR_SERR |
 280                                   EDMA_ERR_SELF_DIS |
 281                                   EDMA_ERR_CRQB_PAR |
 282                                   EDMA_ERR_CRPB_PAR |
 283                                   EDMA_ERR_INTRL_PAR |
 284                                   EDMA_ERR_IORDY |
 285                                   EDMA_ERR_LNK_CTRL_RX_2 |
 286                                   EDMA_ERR_LNK_DATA_RX |
 287                                   EDMA_ERR_LNK_DATA_TX |
 288                                   EDMA_ERR_TRANS_PROTO,
 289         EDMA_EH_FREEZE_5        = EDMA_ERR_D_PAR |
 290                                   EDMA_ERR_PRD_PAR |
 291                                   EDMA_ERR_DEV_DCON |
 292                                   EDMA_ERR_DEV_CON |
 293                                   EDMA_ERR_OVERRUN_5 |
 294                                   EDMA_ERR_UNDERRUN_5 |
 295                                   EDMA_ERR_SELF_DIS_5 |
 296                                   EDMA_ERR_CRQB_PAR |
 297                                   EDMA_ERR_CRPB_PAR |
 298                                   EDMA_ERR_INTRL_PAR |
 299                                   EDMA_ERR_IORDY,
 300
 301         EDMA_REQ_Q_BASE_HI_OFS  = 0x10,
 302         EDMA_REQ_Q_IN_PTR_OFS   = 0x14,         /* also contains BASE_LO */
 303
 304         EDMA_REQ_Q_OUT_PTR_OFS  = 0x18,
 305         EDMA_REQ_Q_PTR_SHIFT    = 5,
 306
 307         EDMA_RSP_Q_BASE_HI_OFS  = 0x1c,
 308         EDMA_RSP_Q_IN_PTR_OFS   = 0x20,
 309         EDMA_RSP_Q_OUT_PTR_OFS  = 0x24,         /* also contains BASE_LO */
 310         EDMA_RSP_Q_PTR_SHIFT    = 3,
 311
 312         EDMA_CMD_OFS            = 0x28,         /* EDMA command register */
 313         EDMA_EN                 = (1 << 0),     /* enable EDMA */
 314         EDMA_DS                 = (1 << 1),     /* disable EDMA; self-negated */
 315         ATA_RST                 = (1 << 2),     /* reset trans/link/phy */
 316
 317         EDMA_IORDY_TMOUT        = 0x34,
 318         EDMA_ARB_CFG            = 0x38,
 319
 320         /* Host private flags (hp_flags) */
 321         MV_HP_FLAG_MSI          = (1 << 0),
 322         MV_HP_ERRATA_50XXB0     = (1 << 1),
 323         MV_HP_ERRATA_50XXB2     = (1 << 2),
 324         MV_HP_ERRATA_60X1B2     = (1 << 3),
 325         MV_HP_ERRATA_60X1C0     = (1 << 4),
 326         MV_HP_ERRATA_XX42A0     = (1 << 5),
 327         MV_HP_GEN_I             = (1 << 6),     /* Generation I: 50xx */
 328         MV_HP_GEN_II            = (1 << 7),     /* Generation II: 60xx */
 329         MV_HP_GEN_IIE           = (1 << 8),     /* Generation IIE: 6042/7042 */
 330         MV_HP_PCIE              = (1 << 9),     /* PCIe bus/regs: 7042 */
 331
 332         /* Port private flags (pp_flags) */
 333         MV_PP_FLAG_EDMA_EN      = (1 << 0),     /* is EDMA engine enabled? */
 334         MV_PP_FLAG_NCQ_EN       = (1 << 1),     /* is EDMA set up for NCQ? */
 335         MV_PP_FLAG_HAD_A_RESET  = (1 << 2),     /* 1st hard reset complete? */
 336 };
 337
 338 #define IS_GEN_I(hpriv) ((hpriv)->hp_flags & MV_HP_GEN_I)
 339 #define IS_GEN_II(hpriv) ((hpriv)->hp_flags & MV_HP_GEN_II)
 340 #define IS_GEN_IIE(hpriv) ((hpriv)->hp_flags & MV_HP_GEN_IIE)
 341
 342 enum {
 343         /* DMA boundary 0xffff is required by the s/g splitting
 344          * we need on /length/ in mv_fill-sg().
 345          */
 346         MV_DMA_BOUNDARY         = 0xffffU,
 347
 348         /* mask of register bits containing lower 32 bits
 349          * of EDMA request queue DMA address
 350          */
 351         EDMA_REQ_Q_BASE_LO_MASK = 0xfffffc00U,
 352
 353         /* ditto, for response queue */
 354         EDMA_RSP_Q_BASE_LO_MASK = 0xffffff00U,
 355 };
 356
 357 enum chip_type {
 358         chip_504x,
 359         chip_508x,
 360         chip_5080,
 361         chip_604x,
 362         chip_608x,
 363         chip_6042,
 364         chip_7042,
 365 };
 366
 367 /* Command ReQuest Block: 32B */
 368 struct mv_crqb {
 369         __le32                  sg_addr;
 370         __le32                  sg_addr_hi;
 371         __le16                  ctrl_flags;
 372         __le16                  ata_cmd[11];
 373 };
 374
 375 struct mv_crqb_iie {
 376         __le32                  addr;
 377         __le32                  addr_hi;
 378         __le32                  flags;
 379         __le32                  len;
 380         __le32                  ata_cmd[4];
 381 };
 382
 383 /* Command ResPonse Block: 8B */
 384 struct mv_crpb {
 385         __le16                  id;
 386         __le16                  flags;
 387         __le32                  tmstmp;
 388 };
 389
 390 /* EDMA Physical Region Descriptor (ePRD); A.K.A. SG */
 391 struct mv_sg {
 392         __le32                  addr;
 393         __le32                  flags_size;
 394         __le32                  addr_hi;
 395         __le32                  reserved;
 396 };
 397
 398 struct mv_port_priv {
 399         struct mv_crqb          *crqb;
 400         dma_addr_t              crqb_dma;
 401         struct mv_crpb          *crpb;
 402         dma_addr_t              crpb_dma;
 403         struct mv_sg            *sg_tbl;
 404         dma_addr_t              sg_tbl_dma;
 405
 406         unsigned int            req_idx;
 407         unsigned int            resp_idx;
 408
 409         u32                     pp_flags;
 410 };
 411
 412 struct mv_port_signal {
 413         u32                     amps;
 414         u32                     pre;
 415 };
 416
 417 struct mv_host_priv {
 418         u32                     hp_flags;
 419         struct mv_port_signal   signal[8];
 420         const struct mv_hw_ops  *ops;
 421         u32                     irq_cause_ofs;
 422         u32                     irq_mask_ofs;
 423         u32                     unmask_all_irqs;
 424 };
 425
 426 struct mv_hw_ops {
 427         void (*phy_errata)(struct mv_host_priv *hpriv, void __iomem *mmio,
 428                            unsigned int port);
 429         void (*enable_leds)(struct mv_host_priv *hpriv, void __iomem *mmio);
 430         void (*read_preamp)(struct mv_host_priv *hpriv, int idx,
 431                            void __iomem *mmio);
 432         int (*reset_hc)(struct mv_host_priv *hpriv, void __iomem *mmio,
 433                         unsigned int n_hc);
 434         void (*reset_flash)(struct mv_host_priv *hpriv, void __iomem *mmio);
 435         void (*reset_bus)(struct pci_dev *pdev, void __iomem *mmio);
 436 };
 437
 438 static void mv_irq_clear(struct ata_port *ap);
 439 static int mv_scr_read(struct ata_port *ap, unsigned int sc_reg_in, u32 *val);
 440 static int mv_scr_write(struct ata_port *ap, unsigned int sc_reg_in, u32 val);
 441 static int mv5_scr_read(struct ata_port *ap, unsigned int sc_reg_in, u32 *val);
 442 static int mv5_scr_write(struct ata_port *ap, unsigned int sc_reg_in, u32 val);
 443 static int mv_port_start(struct ata_port *ap);
 444 static void mv_port_stop(struct ata_port *ap);
 445 static void mv_qc_prep(struct ata_queued_cmd *qc);
 446 static void mv_qc_prep_iie(struct ata_queued_cmd *qc);
 447 static unsigned int mv_qc_issue(struct ata_queued_cmd *qc);
 448 static void mv_error_handler(struct ata_port *ap);
 449 static void mv_post_int_cmd(struct ata_queued_cmd *qc);
 450 static void mv_eh_freeze(struct ata_port *ap);
 451 static void mv_eh_thaw(struct ata_port *ap);
 452 static int mv_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
 453
 454 static void mv5_phy_errata(struct mv_host_priv *hpriv, void __iomem *mmio,
 455                            unsigned int port);
 456 static void mv5_enable_leds(struct mv_host_priv *hpriv, void __iomem *mmio);
 457 static void mv5_read_preamp(struct mv_host_priv *hpriv, int idx,
 458                            void __iomem *mmio);
 459 static int mv5_reset_hc(struct mv_host_priv *hpriv, void __iomem *mmio,
 460                         unsigned int n_hc);
 461 static void mv5_reset_flash(struct mv_host_priv *hpriv, void __iomem *mmio);
 462 static void mv5_reset_bus(struct pci_dev *pdev, void __iomem *mmio);
 463
 464 static void mv6_phy_errata(struct mv_host_priv *hpriv, void __iomem *mmio,
 465                            unsigned int port);
 466 static void mv6_enable_leds(struct mv_host_priv *hpriv, void __iomem *mmio);
 467 static void mv6_read_preamp(struct mv_host_priv *hpriv, int idx,
 468                            void __iomem *mmio);
 469 static int mv6_reset_hc(struct mv_host_priv *hpriv, void __iomem *mmio,
 470                         unsigned int n_hc);
 471 static void mv6_reset_flash(struct mv_host_priv *hpriv, void __iomem *mmio);
 472 static void mv_reset_pci_bus(struct pci_dev *pdev, void __iomem *mmio);
 473 static void mv_channel_reset(struct mv_host_priv *hpriv, void __iomem *mmio,
 474                              unsigned int port_no);
 475 static void mv_edma_cfg(struct mv_port_priv *pp, struct mv_host_priv *hpriv,
 476                         void __iomem *port_mmio, int want_ncq);
 477 static int __mv_stop_dma(struct ata_port *ap);
 478
 479 static struct scsi_host_template mv5_sht = {
 480         .module                 = THIS_MODULE,
 481         .name                   = DRV_NAME,
 482         .ioctl                  = ata_scsi_ioctl,
 483         .queuecommand           = ata_scsi_queuecmd,
 484         .can_queue              = ATA_DEF_QUEUE,
 485         .this_id                = ATA_SHT_THIS_ID,
 486         .sg_tablesize           = MV_MAX_SG_CT / 2,
 487         .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
 488         .emulated               = ATA_SHT_EMULATED,
 489         .use_clustering         = 1,
 490         .proc_name              = DRV_NAME,
 491         .dma_boundary           = MV_DMA_BOUNDARY,
 492         .slave_configure        = ata_scsi_slave_config,
 493         .slave_destroy          = ata_scsi_slave_destroy,
 494         .bios_param             = ata_std_bios_param,
 495 };
 496
 497 static struct scsi_host_template mv6_sht = {
 498         .module                 = THIS_MODULE,
 499         .name                   = DRV_NAME,
 500         .ioctl                  = ata_scsi_ioctl,
 501         .queuecommand           = ata_scsi_queuecmd,
 502         .can_queue              = ATA_DEF_QUEUE,
 503         .this_id                = ATA_SHT_THIS_ID,
 504         .sg_tablesize           = MV_MAX_SG_CT / 2,
 505         .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
 506         .emulated               = ATA_SHT_EMULATED,
 507         .use_clustering         = 1,
 508         .proc_name              = DRV_NAME,
 509         .dma_boundary           = MV_DMA_BOUNDARY,
 510         .slave_configure        = ata_scsi_slave_config,
 511         .slave_destroy          = ata_scsi_slave_destroy,
 512         .bios_param             = ata_std_bios_param,
 513 };
 514
 515 static const struct ata_port_operations mv5_ops = {
 516         .tf_load                = ata_tf_load,
 517         .tf_read                = ata_tf_read,
 518         .check_status           = ata_check_status,
 519         .exec_command           = ata_exec_command,
 520         .dev_select             = ata_std_dev_select,
 521
 522         .cable_detect           = ata_cable_sata,
 523
 524         .qc_prep                = mv_qc_prep,
 525         .qc_issue               = mv_qc_issue,
 526         .data_xfer              = ata_data_xfer,
 527
 528         .irq_clear              = mv_irq_clear,
 529         .irq_on                 = ata_irq_on,
 530
 531         .error_handler          = mv_error_handler,
 532         .post_internal_cmd      = mv_post_int_cmd,
 533         .freeze                 = mv_eh_freeze,
 534         .thaw                   = mv_eh_thaw,
 535
 536         .scr_read               = mv5_scr_read,
 537         .scr_write              = mv5_scr_write,
 538
 539         .port_start             = mv_port_start,
 540         .port_stop              = mv_port_stop,
 541 };
 542
 543 static const struct ata_port_operations mv6_ops = {
 544         .tf_load                = ata_tf_load,
 545         .tf_read                = ata_tf_read,
 546         .check_status           = ata_check_status,
 547         .exec_command           = ata_exec_command,
 548         .dev_select             = ata_std_dev_select,
 549
 550         .cable_detect           = ata_cable_sata,
 551
 552         .qc_prep                = mv_qc_prep,
 553         .qc_issue               = mv_qc_issue,
 554         .data_xfer              = ata_data_xfer,
 555
 556         .irq_clear              = mv_irq_clear,
 557         .irq_on                 = ata_irq_on,
 558
 559         .error_handler          = mv_error_handler,
 560         .post_internal_cmd      = mv_post_int_cmd,
 561         .freeze                 = mv_eh_freeze,
 562         .thaw                   = mv_eh_thaw,
 563
 564         .scr_read               = mv_scr_read,
 565         .scr_write              = mv_scr_write,
 566
 567         .port_start             = mv_port_start,
 568         .port_stop              = mv_port_stop,
 569 };
 570
 571 static const struct ata_port_operations mv_iie_ops = {
 572         .tf_load                = ata_tf_load,
 573         .tf_read                = ata_tf_read,
 574         .check_status           = ata_check_status,
 575         .exec_command           = ata_exec_command,
 576         .dev_select             = ata_std_dev_select,
 577
 578         .cable_detect           = ata_cable_sata,
 579
 580         .qc_prep                = mv_qc_prep_iie,
 581         .qc_issue               = mv_qc_issue,
 582         .data_xfer              = ata_data_xfer,
 583
 584         .irq_clear              = mv_irq_clear,
 585         .irq_on                 = ata_irq_on,
 586
 587         .error_handler          = mv_error_handler,
 588         .post_internal_cmd      = mv_post_int_cmd,
 589         .freeze                 = mv_eh_freeze,
 590         .thaw                   = mv_eh_thaw,
 591
 592         .scr_read               = mv_scr_read,
 593         .scr_write              = mv_scr_write,
 594
 595         .port_start             = mv_port_start,
 596         .port_stop              = mv_port_stop,
 597 };
 598
 599 static const struct ata_port_info mv_port_info[] = {
 600         {  /* chip_504x */
 601                 .flags          = MV_COMMON_FLAGS,
 602                 .pio_mask       = 0x1f, /* pio0-4 */
 603                 .udma_mask      = ATA_UDMA6,
 604                 .port_ops       = &mv5_ops,
 605         },
 606         {  /* chip_508x */
 607                 .flags          = MV_COMMON_FLAGS | MV_FLAG_DUAL_HC,
 608                 .pio_mask       = 0x1f, /* pio0-4 */
 609                 .udma_mask      = ATA_UDMA6,
 610                 .port_ops       = &mv5_ops,
 611         },
 612         {  /* chip_5080 */
 613                 .flags          = MV_COMMON_FLAGS | MV_FLAG_DUAL_HC,
 614                 .pio_mask       = 0x1f, /* pio0-4 */
 615                 .udma_mask      = ATA_UDMA6,
 616                 .port_ops       = &mv5_ops,
 617         },
 618         {  /* chip_604x */
 619                 .flags          = MV_COMMON_FLAGS | MV_6XXX_FLAGS,
 620                 .pio_mask       = 0x1f, /* pio0-4 */
 621                 .udma_mask      = ATA_UDMA6,
 622                 .port_ops       = &mv6_ops,
 623         },
 624         {  /* chip_608x */
 625                 .flags          = MV_COMMON_FLAGS | MV_6XXX_FLAGS |
 626                                   MV_FLAG_DUAL_HC,
 627                 .pio_mask       = 0x1f, /* pio0-4 */
 628                 .udma_mask      = ATA_UDMA6,
 629                 .port_ops       = &mv6_ops,
 630         },
 631         {  /* chip_6042 */
 632                 .flags          = MV_COMMON_FLAGS | MV_6XXX_FLAGS,
 633                 .pio_mask       = 0x1f, /* pio0-4 */
 634                 .udma_mask      = ATA_UDMA6,
 635                 .port_ops       = &mv_iie_ops,
 636         },
 637         {  /* chip_7042 */
 638                 .flags          = MV_COMMON_FLAGS | MV_6XXX_FLAGS,
 639                 .pio_mask       = 0x1f, /* pio0-4 */
 640                 .udma_mask      = ATA_UDMA6,
 641                 .port_ops       = &mv_iie_ops,
 642         },
 643 };
 644
 645 static const struct pci_device_id mv_pci_tbl[] = {
 646         { PCI_VDEVICE(MARVELL, 0x5040), chip_504x },
 647         { PCI_VDEVICE(MARVELL, 0x5041), chip_504x },
 648         { PCI_VDEVICE(MARVELL, 0x5080), chip_5080 },
 649         { PCI_VDEVICE(MARVELL, 0x5081), chip_508x },
 650         /* RocketRAID 1740/174x have different identifiers */
 651         { PCI_VDEVICE(TTI, 0x1740), chip_508x },
 652         { PCI_VDEVICE(TTI, 0x1742), chip_508x },
 653
 654         { PCI_VDEVICE(MARVELL, 0x6040), chip_604x },
 655         { PCI_VDEVICE(MARVELL, 0x6041), chip_604x },
 656         { PCI_VDEVICE(MARVELL, 0x6042), chip_6042 },
 657         { PCI_VDEVICE(MARVELL, 0x6080), chip_608x },
 658         { PCI_VDEVICE(MARVELL, 0x6081), chip_608x },
 659
 660         { PCI_VDEVICE(ADAPTEC2, 0x0241), chip_604x },
 661
 662         /* Adaptec 1430SA */
 663         { PCI_VDEVICE(ADAPTEC2, 0x0243), chip_7042 },
 664
 665         /* Marvell 7042 support */
 666         { PCI_VDEVICE(MARVELL, 0x7042), chip_7042 },
 667
 668         /* Highpoint RocketRAID PCIe series */
 669         { PCI_VDEVICE(TTI, 0x2300), chip_7042 },
 670         { PCI_VDEVICE(TTI, 0x2310), chip_7042 },
 671
 672         { }                     /* terminate list */
 673 };
 674
 675 static struct pci_driver mv_pci_driver = {
 676         .name                   = DRV_NAME,
 677         .id_table               = mv_pci_tbl,
 678         .probe                  = mv_init_one,
 679         .remove                 = ata_pci_remove_one,
 680 };
 681
 682 static const struct mv_hw_ops mv5xxx_ops = {
 683         .phy_errata             = mv5_phy_errata,
 684         .enable_leds            = mv5_enable_leds,
 685         .read_preamp            = mv5_read_preamp,
 686         .reset_hc               = mv5_reset_hc,
 687         .reset_flash            = mv5_reset_flash,
 688         .reset_bus              = mv5_reset_bus,
 689 };
 690
 691 static const struct mv_hw_ops mv6xxx_ops = {
 692         .phy_errata             = mv6_phy_errata,
 693         .enable_leds            = mv6_enable_leds,
 694         .read_preamp            = mv6_read_preamp,
 695         .reset_hc               = mv6_reset_hc,
 696         .reset_flash            = mv6_reset_flash,
 697         .reset_bus              = mv_reset_pci_bus,
 698 };
 699
 700 /*
 701  * module options
 702  */
 703 static int msi;       /* Use PCI msi; either zero (off, default) or non-zero */
 704
 705
 706 /* move to PCI layer or libata core? */
 707 static int pci_go_64(struct pci_dev *pdev)
 708 {
 709         int rc;
 710
 711         if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)) {
 712                 rc = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
 713                 if (rc) {
 714                         rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
 715                         if (rc) {
 716                                 dev_printk(KERN_ERR, &pdev->dev,
 717                                            "64-bit DMA enable failed\n");
 718                                 return rc;
 719                         }
 720                 }
 721         } else {
 722                 rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
 723                 if (rc) {
 724                         dev_printk(KERN_ERR, &pdev->dev,
 725                                    "32-bit DMA enable failed\n");
 726                         return rc;
 727                 }
 728                 rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
 729                 if (rc) {
 730                         dev_printk(KERN_ERR, &pdev->dev,
 731                                    "32-bit consistent DMA enable failed\n");
 732                         return rc;
 733                 }
 734         }
 735
 736         return rc;
 737 }
 738
 739 /*
 740  * Functions
 741  */
 742
 743 static inline void writelfl(unsigned long data, void __iomem *addr)
 744 {
 745         writel(data, addr);
 746         (void) readl(addr);     /* flush to avoid PCI posted write */
 747 }
 748
 749 static inline void __iomem *mv_hc_base(void __iomem *base, unsigned int hc)
 750 {
 751         return (base + MV_SATAHC0_REG_BASE + (hc * MV_SATAHC_REG_SZ));
 752 }
 753
 754 static inline unsigned int mv_hc_from_port(unsigned int port)
 755 {
 756         return port >> MV_PORT_HC_SHIFT;
 757 }
 758
 759 static inline unsigned int mv_hardport_from_port(unsigned int port)
 760 {
 761         return port & MV_PORT_MASK;
 762 }
 763
 764 static inline void __iomem *mv_hc_base_from_port(void __iomem *base,
 765                                                  unsigned int port)
 766 {
 767         return mv_hc_base(base, mv_hc_from_port(port));
 768 }
 769
 770 static inline void __iomem *mv_port_base(void __iomem *base, unsigned int port)
 771 {
 772         return  mv_hc_base_from_port(base, port) +
 773                 MV_SATAHC_ARBTR_REG_SZ +
 774                 (mv_hardport_from_port(port) * MV_PORT_REG_SZ);
 775 }
 776
 777 static inline void __iomem *mv_ap_base(struct ata_port *ap)
 778 {
 779         return mv_port_base(ap->host->iomap[MV_PRIMARY_BAR], ap->port_no);
 780 }
 781
 782 static inline int mv_get_hc_count(unsigned long port_flags)
 783 {
 784         return ((port_flags & MV_FLAG_DUAL_HC) ? 2 : 1);
 785 }
 786
 787 static void mv_irq_clear(struct ata_port *ap)
 788 {
 789 }
 790
 791 static void mv_set_edma_ptrs(void __iomem *port_mmio,
 792                              struct mv_host_priv *hpriv,
 793                              struct mv_port_priv *pp)
 794 {
 795         u32 index;
 796
 797         /*
 798          * initialize request queue
 799          */
 800         index = (pp->req_idx & MV_MAX_Q_DEPTH_MASK) << EDMA_REQ_Q_PTR_SHIFT;
 801
 802         WARN_ON(pp->crqb_dma & 0x3ff);
 803         writel((pp->crqb_dma >> 16) >> 16, port_mmio + EDMA_REQ_Q_BASE_HI_OFS);
 804         writelfl((pp->crqb_dma & EDMA_REQ_Q_BASE_LO_MASK) | index,
 805                  port_mmio + EDMA_REQ_Q_IN_PTR_OFS);
 806
 807         if (hpriv->hp_flags & MV_HP_ERRATA_XX42A0)
 808                 writelfl((pp->crqb_dma & 0xffffffff) | index,
 809                          port_mmio + EDMA_REQ_Q_OUT_PTR_OFS);
 810         else
 811                 writelfl(index, port_mmio + EDMA_REQ_Q_OUT_PTR_OFS);
 812
 813         /*
 814          * initialize response queue
 815          */
 816         index = (pp->resp_idx & MV_MAX_Q_DEPTH_MASK) << EDMA_RSP_Q_PTR_SHIFT;
 817
 818         WARN_ON(pp->crpb_dma & 0xff);
 819         writel((pp->crpb_dma >> 16) >> 16, port_mmio + EDMA_RSP_Q_BASE_HI_OFS);
 820
 821         if (hpriv->hp_flags & MV_HP_ERRATA_XX42A0)
 822                 writelfl((pp->crpb_dma & 0xffffffff) | index,
 823                          port_mmio + EDMA_RSP_Q_IN_PTR_OFS);
 824         else
 825                 writelfl(index, port_mmio + EDMA_RSP_Q_IN_PTR_OFS);
 826
 827         writelfl((pp->crpb_dma & EDMA_RSP_Q_BASE_LO_MASK) | index,
 828                  port_mmio + EDMA_RSP_Q_OUT_PTR_OFS);
 829 }
 830
 831 /**
 832  *      mv_start_dma - Enable eDMA engine
 833  *      @base: port base address
 834  *      @pp: port private data
 835  *
 836  *      Verify the local cache of the eDMA state is accurate with a
 837  *      WARN_ON.
 838  *
 839  *      LOCKING:
 840  *      Inherited from caller.
 841  */
 842 static void mv_start_dma(struct ata_port *ap, void __iomem *port_mmio,
 843                          struct mv_port_priv *pp, u8 protocol)
 844 {
 845         int want_ncq = (protocol == ATA_PROT_NCQ);
 846
 847         if (pp->pp_flags & MV_PP_FLAG_EDMA_EN) {
 848                 int using_ncq = ((pp->pp_flags & MV_PP_FLAG_NCQ_EN) != 0);
 849                 if (want_ncq != using_ncq)
 850                         __mv_stop_dma(ap);
 851         }
 852         if (!(pp->pp_flags & MV_PP_FLAG_EDMA_EN)) {
 853                 struct mv_host_priv *hpriv = ap->host->private_data;
 854                 int hard_port = mv_hardport_from_port(ap->port_no);
 855                 void __iomem *hc_mmio = mv_hc_base_from_port(
 856                                 ap->host->iomap[MV_PRIMARY_BAR], hard_port);
 857                 u32 hc_irq_cause, ipending;
 858
 859                 /* clear EDMA event indicators, if any */
 860                 writelfl(0, port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
 861
 862                 /* clear EDMA interrupt indicator, if any */
 863                 hc_irq_cause = readl(hc_mmio + HC_IRQ_CAUSE_OFS);
 864                 ipending = (DEV_IRQ << hard_port) |
 865                                 (CRPB_DMA_DONE << hard_port);
 866                 if (hc_irq_cause & ipending) {
 867                         writelfl(hc_irq_cause & ~ipending,
 868                                  hc_mmio + HC_IRQ_CAUSE_OFS);
 869                 }
 870
 871                 mv_edma_cfg(pp, hpriv, port_mmio, want_ncq);
 872
 873                 /* clear FIS IRQ Cause */
 874                 writelfl(0, port_mmio + SATA_FIS_IRQ_CAUSE_OFS);
 875
 876                 mv_set_edma_ptrs(port_mmio, hpriv, pp);
 877
 878                 writelfl(EDMA_EN, port_mmio + EDMA_CMD_OFS);
 879                 pp->pp_flags |= MV_PP_FLAG_EDMA_EN;
 880         }
 881         WARN_ON(!(EDMA_EN & readl(port_mmio + EDMA_CMD_OFS)));
 882 }
 883
 884 /**
 885  *      __mv_stop_dma - Disable eDMA engine
 886  *      @ap: ATA channel to manipulate
 887  *
 888  *      Verify the local cache of the eDMA state is accurate with a
 889  *      WARN_ON.
 890  *
 891  *      LOCKING:
 892  *      Inherited from caller.
 893  */
 894 static int __mv_stop_dma(struct ata_port *ap)
 895 {
 896         void __iomem *port_mmio = mv_ap_base(ap);
 897         struct mv_port_priv *pp = ap->private_data;
 898         u32 reg;
 899         int i, err = 0;
 900
 901         if (pp->pp_flags & MV_PP_FLAG_EDMA_EN) {
 902                 /* Disable EDMA if active.   The disable bit auto clears.
 903                  */
 904                 writelfl(EDMA_DS, port_mmio + EDMA_CMD_OFS);
 905                 pp->pp_flags &= ~MV_PP_FLAG_EDMA_EN;
 906         } else {
 907                 WARN_ON(EDMA_EN & readl(port_mmio + EDMA_CMD_OFS));
 908         }
 909
 910         /* now properly wait for the eDMA to stop */
 911         for (i = 1000; i > 0; i--) {
 912                 reg = readl(port_mmio + EDMA_CMD_OFS);
 913                 if (!(reg & EDMA_EN))
 914                         break;
 915
 916                 udelay(100);
 917         }
 918
 919         if (reg & EDMA_EN) {
 920                 ata_port_printk(ap, KERN_ERR, "Unable to stop eDMA\n");
 921                 err = -EIO;
 922         }
 923
 924         return err;
 925 }
 926
 927 static int mv_stop_dma(struct ata_port *ap)
 928 {
 929         unsigned long flags;
 930         int rc;
 931
 932         spin_lock_irqsave(&ap->host->lock, flags);
 933         rc = __mv_stop_dma(ap);
 934         spin_unlock_irqrestore(&ap->host->lock, flags);
 935
 936         return rc;
 937 }
 938
 939 #ifdef ATA_DEBUG
 940 static void mv_dump_mem(void __iomem *start, unsigned bytes)
 941 {
 942         int b, w;
 943         for (b = 0; b < bytes; ) {
 944                 DPRINTK("%p: ", start + b);
 945                 for (w = 0; b < bytes && w < 4; w++) {
 946                         printk("%08x ", readl(start + b));
 947                         b += sizeof(u32);
 948                 }
 949                 printk("\n");
 950         }
 951 }
 952 #endif
 953
 954 static void mv_dump_pci_cfg(struct pci_dev *pdev, unsigned bytes)
 955 {
 956 #ifdef ATA_DEBUG
 957         int b, w;
 958         u32 dw;
 959         for (b = 0; b < bytes; ) {
 960                 DPRINTK("%02x: ", b);
 961                 for (w = 0; b < bytes && w < 4; w++) {
 962                         (void) pci_read_config_dword(pdev, b, &dw);
 963                         printk("%08x ", dw);
 964                         b += sizeof(u32);
 965                 }
 966                 printk("\n");
 967         }
 968 #endif
 969 }
 970 static void mv_dump_all_regs(void __iomem *mmio_base, int port,
 971                              struct pci_dev *pdev)
 972 {
 973 #ifdef ATA_DEBUG
 974         void __iomem *hc_base = mv_hc_base(mmio_base,
 975                                            port >> MV_PORT_HC_SHIFT);
 976         void __iomem *port_base;
 977         int start_port, num_ports, p, start_hc, num_hcs, hc;
 978
 979         if (0 > port) {
 980                 start_hc = start_port = 0;
 981                 num_ports = 8;          /* shld be benign for 4 port devs */
 982                 num_hcs = 2;
 983         } else {
 984                 start_hc = port >> MV_PORT_HC_SHIFT;
 985                 start_port = port;
 986                 num_ports = num_hcs = 1;
 987         }
 988         DPRINTK("All registers for port(s) %u-%u:\n", start_port,
 989                 num_ports > 1 ? num_ports - 1 : start_port);
 990
 991         if (NULL != pdev) {
 992                 DPRINTK("PCI config space regs:\n");
 993                 mv_dump_pci_cfg(pdev, 0x68);
 994         }
 995         DPRINTK("PCI regs:\n");
 996         mv_dump_mem(mmio_base+0xc00, 0x3c);
 997         mv_dump_mem(mmio_base+0xd00, 0x34);
 998         mv_dump_mem(mmio_base+0xf00, 0x4);
 999         mv_dump_mem(mmio_base+0x1d00, 0x6c);
1000         for (hc = start_hc; hc < start_hc + num_hcs; hc++) {
1001                 hc_base = mv_hc_base(mmio_base, hc);
1002                 DPRINTK("HC regs (HC %i):\n", hc);
1003                 mv_dump_mem(hc_base, 0x1c);
1004         }
1005         for (p = start_port; p < start_port + num_ports; p++) {
1006                 port_base = mv_port_base(mmio_base, p);
1007                 DPRINTK("EDMA regs (port %i):\n", p);
1008                 mv_dump_mem(port_base, 0x54);
1009                 DPRINTK("SATA regs (port %i):\n", p);
1010                 mv_dump_mem(port_base+0x300, 0x60);
1011         }
1012 #endif
1013 }
1014
1015 static unsigned int mv_scr_offset(unsigned int sc_reg_in)
1016 {
1017         unsigned int ofs;
1018
1019         switch (sc_reg_in) {
1020         case SCR_STATUS:
1021         case SCR_CONTROL:
1022         case SCR_ERROR:
1023                 ofs = SATA_STATUS_OFS + (sc_reg_in * sizeof(u32));
1024                 break;
1025         case SCR_ACTIVE:
1026                 ofs = SATA_ACTIVE_OFS;   /* active is not with the others */
1027                 break;
1028         default:
1029                 ofs = 0xffffffffU;
1030                 break;
1031         }
1032         return ofs;
1033 }
1034
1035 static int mv_scr_read(struct ata_port *ap, unsigned int sc_reg_in, u32 *val)
1036 {
1037         unsigned int ofs = mv_scr_offset(sc_reg_in);
1038
1039         if (ofs != 0xffffffffU) {
1040                 *val = readl(mv_ap_base(ap) + ofs);
1041                 return 0;
1042         } else
1043                 return -EINVAL;
1044 }
1045
1046 static int mv_scr_write(struct ata_port *ap, unsigned int sc_reg_in, u32 val)
1047 {
1048         unsigned int ofs = mv_scr_offset(sc_reg_in);
1049
1050         if (ofs != 0xffffffffU) {
1051                 writelfl(val, mv_ap_base(ap) + ofs);
1052                 return 0;
1053         } else
1054                 return -EINVAL;
1055 }
1056
1057 static void mv_edma_cfg(struct mv_port_priv *pp, struct mv_host_priv *hpriv,
1058                         void __iomem *port_mmio, int want_ncq)
1059 {
1060         u32 cfg;
1061
1062         /* set up non-NCQ EDMA configuration */
1063         cfg = EDMA_CFG_Q_DEPTH;         /* always 0x1f for *all* chips */
1064
1065         if (IS_GEN_I(hpriv))
1066                 cfg |= (1 << 8);        /* enab config burst size mask */
1067
1068         else if (IS_GEN_II(hpriv))
1069                 cfg |= EDMA_CFG_RD_BRST_EXT | EDMA_CFG_WR_BUFF_LEN;
1070
1071         else if (IS_GEN_IIE(hpriv)) {
1072                 cfg |= (1 << 23);       /* do not mask PM field in rx'd FIS */
1073                 cfg |= (1 << 22);       /* enab 4-entry host queue cache */
1074                 cfg |= (1 << 18);       /* enab early completion */
1075                 cfg |= (1 << 17);       /* enab cut-through (dis stor&forwrd) */
1076         }
1077
1078         if (want_ncq) {
1079                 cfg |= EDMA_CFG_NCQ;
1080                 pp->pp_flags |=  MV_PP_FLAG_NCQ_EN;
1081         } else
1082                 pp->pp_flags &= ~MV_PP_FLAG_NCQ_EN;
1083
1084         writelfl(cfg, port_mmio + EDMA_CFG_OFS);
1085 }
1086
1087 /**
1088  *      mv_port_start - Port specific init/start routine.
1089  *      @ap: ATA channel to manipulate
1090  *
1091  *      Allocate and point to DMA memory, init port private memory,
1092  *      zero indices.
1093  *
1094  *      LOCKING:
1095  *      Inherited from caller.
1096  */
1097 static int mv_port_start(struct ata_port *ap)
1098 {
1099         struct device *dev = ap->host->dev;
1100         struct mv_host_priv *hpriv = ap->host->private_data;
1101         struct mv_port_priv *pp;
1102         void __iomem *port_mmio = mv_ap_base(ap);
1103         void *mem;
1104         dma_addr_t mem_dma;
1105         unsigned long flags;
1106         int rc;
1107
1108         pp = devm_kzalloc(dev, sizeof(*pp), GFP_KERNEL);
1109         if (!pp)
1110                 return -ENOMEM;
1111
1112         mem = dmam_alloc_coherent(dev, MV_PORT_PRIV_DMA_SZ, &mem_dma,
1113                                   GFP_KERNEL);
1114         if (!mem)
1115                 return -ENOMEM;
1116         memset(mem, 0, MV_PORT_PRIV_DMA_SZ);
1117
1118         rc = ata_pad_alloc(ap, dev);
1119         if (rc)
1120                 return rc;
1121
1122         /* First item in chunk of DMA memory:
1123          * 32-slot command request table (CRQB), 32 bytes each in size
1124          */
1125         pp->crqb = mem;
1126         pp->crqb_dma = mem_dma;
1127         mem += MV_CRQB_Q_SZ;
1128         mem_dma += MV_CRQB_Q_SZ;
1129
1130         /* Second item:
1131          * 32-slot command response table (CRPB), 8 bytes each in size
1132          */
1133         pp->crpb = mem;
1134         pp->crpb_dma = mem_dma;
1135         mem += MV_CRPB_Q_SZ;
1136         mem_dma += MV_CRPB_Q_SZ;
1137
1138         /* Third item:
1139          * Table of scatter-gather descriptors (ePRD), 16 bytes each
1140          */
1141         pp->sg_tbl = mem;
1142         pp->sg_tbl_dma = mem_dma;
1143
1144         spin_lock_irqsave(&ap->host->lock, flags);
1145
1146         mv_edma_cfg(pp, hpriv, port_mmio, 0);
1147
1148         mv_set_edma_ptrs(port_mmio, hpriv, pp);
1149
1150         spin_unlock_irqrestore(&ap->host->lock, flags);
1151
1152         /* Don't turn on EDMA here...do it before DMA commands only.  Else
1153          * we'll be unable to send non-data, PIO, etc due to restricted access
1154          * to shadow regs.
1155          */
1156         ap->private_data = pp;
1157         return 0;
1158 }
1159
1160 /**
1161  *      mv_port_stop - Port specific cleanup/stop routine.
1162  *      @ap: ATA channel to manipulate
1163  *
1164  *      Stop DMA, cleanup port memory.
1165  *
1166  *      LOCKING:
1167  *      This routine uses the host lock to protect the DMA stop.
1168  */
1169 static void mv_port_stop(struct ata_port *ap)
1170 {
1171         mv_stop_dma(ap);
1172 }
1173
1174 /**
1175  *      mv_fill_sg - Fill out the Marvell ePRD (scatter gather) entries
1176  *      @qc: queued command whose SG list to source from
1177  *
1178  *      Populate the SG list and mark the last entry.
1179  *
1180  *      LOCKING:
1181  *      Inherited from caller.
1182  */
1183 static void mv_fill_sg(struct ata_queued_cmd *qc)
1184 {
1185         struct mv_port_priv *pp = qc->ap->private_data;
1186         struct scatterlist *sg;
1187         struct mv_sg *mv_sg, *last_sg = NULL;
1188         unsigned int si;
1189
1190         mv_sg = pp->sg_tbl;
1191         for_each_sg(qc->sg, sg, qc->n_elem, si) {
1192                 dma_addr_t addr = sg_dma_address(sg);
1193                 u32 sg_len = sg_dma_len(sg);
1194
1195                 while (sg_len) {
1196                         u32 offset = addr & 0xffff;
1197                         u32 len = sg_len;
1198
1199                         if ((offset + sg_len > 0x10000))
1200                                 len = 0x10000 - offset;
1201
1202                         mv_sg->addr = cpu_to_le32(addr & 0xffffffff);
1203                         mv_sg->addr_hi = cpu_to_le32((addr >> 16) >> 16);
1204                         mv_sg->flags_size = cpu_to_le32(len & 0xffff);
1205
1206                         sg_len -= len;
1207                         addr += len;
1208
1209                         last_sg = mv_sg;
1210                         mv_sg++;
1211                 }
1212         }
1213
1214         if (likely(last_sg))
1215                 last_sg->flags_size |= cpu_to_le32(EPRD_FLAG_END_OF_TBL);
1216 }
1217
1218 static void mv_crqb_pack_cmd(__le16 *cmdw, u8 data, u8 addr, unsigned last)
1219 {
1220         u16 tmp = data | (addr << CRQB_CMD_ADDR_SHIFT) | CRQB_CMD_CS |
1221                 (last ? CRQB_CMD_LAST : 0);
1222         *cmdw = cpu_to_le16(tmp);
1223 }
1224
1225 /**
1226  *      mv_qc_prep - Host specific command preparation.
1227  *      @qc: queued command to prepare
1228  *
1229  *      This routine simply redirects to the general purpose routine
1230  *      if command is not DMA.  Else, it handles prep of the CRQB
1231  *      (command request block), does some sanity checking, and calls
1232  *      the SG load routine.
1233  *
1234  *      LOCKING:
1235  *      Inherited from caller.
1236  */
1237 static void mv_qc_prep(struct ata_queued_cmd *qc)
1238 {
1239         struct ata_port *ap = qc->ap;
1240         struct mv_port_priv *pp = ap->private_data;
1241         __le16 *cw;
1242         struct ata_taskfile *tf;
1243         u16 flags = 0;
1244         unsigned in_index;
1245
1246         if (qc->tf.protocol != ATA_PROT_DMA)
1247                 return;
1248
1249         /* Fill in command request block
1250          */
1251         if (!(qc->tf.flags & ATA_TFLAG_WRITE))
1252                 flags |= CRQB_FLAG_READ;
1253         WARN_ON(MV_MAX_Q_DEPTH <= qc->tag);
1254         flags |= qc->tag << CRQB_TAG_SHIFT;
1255
1256         /* get current queue index from software */
1257         in_index = pp->req_idx & MV_MAX_Q_DEPTH_MASK;
1258
1259         pp->crqb[in_index].sg_addr =
1260                 cpu_to_le32(pp->sg_tbl_dma & 0xffffffff);
1261         pp->crqb[in_index].sg_addr_hi =
1262                 cpu_to_le32((pp->sg_tbl_dma >> 16) >> 16);
1263         pp->crqb[in_index].ctrl_flags = cpu_to_le16(flags);
1264
1265         cw = &pp->crqb[in_index].ata_cmd[0];
1266         tf = &qc->tf;
1267
1268         /* Sadly, the CRQB cannot accomodate all registers--there are
1269          * only 11 bytes...so we must pick and choose required
1270          * registers based on the command.  So, we drop feature and
1271          * hob_feature for [RW] DMA commands, but they are needed for
1272          * NCQ.  NCQ will drop hob_nsect.
1273          */
1274         switch (tf->command) {
1275         case ATA_CMD_READ:
1276         case ATA_CMD_READ_EXT:
1277         case ATA_CMD_WRITE:
1278         case ATA_CMD_WRITE_EXT:
1279         case ATA_CMD_WRITE_FUA_EXT:
1280                 mv_crqb_pack_cmd(cw++, tf->hob_nsect, ATA_REG_NSECT, 0);
1281                 break;
1282 #ifdef LIBATA_NCQ               /* FIXME: remove this line when NCQ added */
1283         case ATA_CMD_FPDMA_READ:
1284         case ATA_CMD_FPDMA_WRITE:
1285                 mv_crqb_pack_cmd(cw++, tf->hob_feature, ATA_REG_FEATURE, 0);
1286                 mv_crqb_pack_cmd(cw++, tf->feature, ATA_REG_FEATURE, 0);
1287                 break;
1288 #endif                          /* FIXME: remove this line when NCQ added */
1289         default:
1290                 /* The only other commands EDMA supports in non-queued and
1291                  * non-NCQ mode are: [RW] STREAM DMA and W DMA FUA EXT, none
1292                  * of which are defined/used by Linux.  If we get here, this
1293                  * driver needs work.
1294                  *
1295                  * FIXME: modify libata to give qc_prep a return value and
1296                  * return error here.
1297                  */
1298                 BUG_ON(tf->command);
1299                 break;
1300         }
1301         mv_crqb_pack_cmd(cw++, tf->nsect, ATA_REG_NSECT, 0);
1302         mv_crqb_pack_cmd(cw++, tf->hob_lbal, ATA_REG_LBAL, 0);
1303         mv_crqb_pack_cmd(cw++, tf->lbal, ATA_REG_LBAL, 0);
1304         mv_crqb_pack_cmd(cw++, tf->hob_lbam, ATA_REG_LBAM, 0);
1305         mv_crqb_pack_cmd(cw++, tf->lbam, ATA_REG_LBAM, 0);
1306         mv_crqb_pack_cmd(cw++, tf->hob_lbah, ATA_REG_LBAH, 0);
1307         mv_crqb_pack_cmd(cw++, tf->lbah, ATA_REG_LBAH, 0);
1308         mv_crqb_pack_cmd(cw++, tf->device, ATA_REG_DEVICE, 0);
1309         mv_crqb_pack_cmd(cw++, tf->command, ATA_REG_CMD, 1);    /* last */
1310
1311         if (!(qc->flags & ATA_QCFLAG_DMAMAP))
1312                 return;
1313         mv_fill_sg(qc);
1314 }
1315
1316 /**
1317  *      mv_qc_prep_iie - Host specific command preparation.
1318  *      @qc: queued command to prepare
1319  *
1320  *      This routine simply redirects to the general purpose routine
1321  *      if command is not DMA.  Else, it handles prep of the CRQB
1322  *      (command request block), does some sanity checking, and calls
1323  *      the SG load routine.
1324  *
1325  *      LOCKING:
1326  *      Inherited from caller.
1327  */
1328 static void mv_qc_prep_iie(struct ata_queued_cmd *qc)
1329 {
1330         struct ata_port *ap = qc->ap;
1331         struct mv_port_priv *pp = ap->private_data;
1332         struct mv_crqb_iie *crqb;
1333         struct ata_taskfile *tf;
1334         unsigned in_index;
1335         u32 flags = 0;
1336
1337         if (qc->tf.protocol != ATA_PROT_DMA)
1338                 return;
1339
1340         /* Fill in Gen IIE command request block
1341          */
1342         if (!(qc->tf.flags & ATA_TFLAG_WRITE))
1343                 flags |= CRQB_FLAG_READ;
1344
1345         WARN_ON(MV_MAX_Q_DEPTH <= qc->tag);
1346         flags |= qc->tag << CRQB_TAG_SHIFT;
1347         flags |= qc->tag << CRQB_HOSTQ_SHIFT;
1348
1349         /* get current queue index from software */
1350         in_index = pp->req_idx & MV_MAX_Q_DEPTH_MASK;
1351
1352         crqb = (struct mv_crqb_iie *) &pp->crqb[in_index];
1353         crqb->addr = cpu_to_le32(pp->sg_tbl_dma & 0xffffffff);
1354         crqb->addr_hi = cpu_to_le32((pp->sg_tbl_dma >> 16) >> 16);
1355         crqb->flags = cpu_to_le32(flags);
1356
1357         tf = &qc->tf;
1358         crqb->ata_cmd[0] = cpu_to_le32(
1359                         (tf->command << 16) |
1360                         (tf->feature << 24)
1361                 );
1362         crqb->ata_cmd[1] = cpu_to_le32(
1363                         (tf->lbal << 0) |
1364                         (tf->lbam << 8) |
1365                         (tf->lbah << 16) |
1366                         (tf->device << 24)
1367                 );
1368         crqb->ata_cmd[2] = cpu_to_le32(
1369                         (tf->hob_lbal << 0) |
1370                         (tf->hob_lbam << 8) |
1371                         (tf->hob_lbah << 16) |
1372                         (tf->hob_feature << 24)
1373                 );
1374         crqb->ata_cmd[3] = cpu_to_le32(
1375                         (tf->nsect << 0) |
1376                         (tf->hob_nsect << 8)
1377                 );
1378
1379         if (!(qc->flags & ATA_QCFLAG_DMAMAP))
1380                 return;
1381         mv_fill_sg(qc);
1382 }
1383
1384 /**
1385  *      mv_qc_issue - Initiate a command to the host
1386  *      @qc: queued command to start
1387  *
1388  *      This routine simply redirects to the general purpose routine
1389  *      if command is not DMA.  Else, it sanity checks our local
1390  *      caches of the request producer/consumer indices then enables
1391  *      DMA and bumps the request producer index.
1392  *
1393  *      LOCKING:
1394  *      Inherited from caller.
1395  */
1396 static unsigned int mv_qc_issue(struct ata_queued_cmd *qc)
1397 {
1398         struct ata_port *ap = qc->ap;
1399         void __iomem *port_mmio = mv_ap_base(ap);
1400         struct mv_port_priv *pp = ap->private_data;
1401         u32 in_index;
1402
1403         if (qc->tf.protocol != ATA_PROT_DMA) {
1404                 /* We're about to send a non-EDMA capable command to the
1405                  * port.  Turn off EDMA so there won't be problems accessing
1406                  * shadow block, etc registers.
1407                  */
1408                 __mv_stop_dma(ap);
1409                 return ata_qc_issue_prot(qc);
1410         }
1411
1412         mv_start_dma(ap, port_mmio, pp, qc->tf.protocol);
1413
1414         in_index = pp->req_idx & MV_MAX_Q_DEPTH_MASK;
1415
1416         /* until we do queuing, the queue should be empty at this point */
1417         WARN_ON(in_index != ((readl(port_mmio + EDMA_REQ_Q_OUT_PTR_OFS)
1418                 >> EDMA_REQ_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK));
1419
1420         pp->req_idx++;
1421
1422         in_index = (pp->req_idx & MV_MAX_Q_DEPTH_MASK) << EDMA_REQ_Q_PTR_SHIFT;
1423
1424         /* and write the request in pointer to kick the EDMA to life */
1425         writelfl((pp->crqb_dma & EDMA_REQ_Q_BASE_LO_MASK) | in_index,
1426                  port_mmio + EDMA_REQ_Q_IN_PTR_OFS);
1427
1428         return 0;
1429 }
1430
1431 /**
1432  *      mv_err_intr - Handle error interrupts on the port
1433  *      @ap: ATA channel to manipulate
1434  *      @reset_allowed: bool: 0 == don't trigger from reset here
1435  *
1436  *      In most cases, just clear the interrupt and move on.  However,
1437  *      some cases require an eDMA reset, which is done right before
1438  *      the COMRESET in mv_phy_reset().  The SERR case requires a
1439  *      clear of pending errors in the SATA SERROR register.  Finally,
1440  *      if the port disabled DMA, update our cached copy to match.
1441  *
1442  *      LOCKING:
1443  *      Inherited from caller.
1444  */
1445 static void mv_err_intr(struct ata_port *ap, struct ata_queued_cmd *qc)
1446 {
1447         void __iomem *port_mmio = mv_ap_base(ap);
1448         u32 edma_err_cause, eh_freeze_mask, serr = 0;
1449         struct mv_port_priv *pp = ap->private_data;
1450         struct mv_host_priv *hpriv = ap->host->private_data;
1451         unsigned int edma_enabled = (pp->pp_flags & MV_PP_FLAG_EDMA_EN);
1452         unsigned int action = 0, err_mask = 0;
1453         struct ata_eh_info *ehi = &ap->link.eh_info;
1454
1455         ata_ehi_clear_desc(ehi);
1456
1457         if (!edma_enabled) {
1458                 /* just a guess: do we need to do this? should we
1459                  * expand this, and do it in all cases?
1460                  */
1461                 sata_scr_read(&ap->link, SCR_ERROR, &serr);
1462                 sata_scr_write_flush(&ap->link, SCR_ERROR, serr);
1463         }
1464
1465         edma_err_cause = readl(port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
1466
1467         ata_ehi_push_desc(ehi, "edma_err 0x%08x", edma_err_cause);
1468
1469         /*
1470          * all generations share these EDMA error cause bits
1471          */
1472
1473         if (edma_err_cause & EDMA_ERR_DEV)
1474                 err_mask |= AC_ERR_DEV;
1475         if (edma_err_cause & (EDMA_ERR_D_PAR | EDMA_ERR_PRD_PAR |
1476                         EDMA_ERR_CRQB_PAR | EDMA_ERR_CRPB_PAR |
1477                         EDMA_ERR_INTRL_PAR)) {
1478                 err_mask |= AC_ERR_ATA_BUS;
1479                 action |= ATA_EH_HARDRESET;
1480                 ata_ehi_push_desc(ehi, "parity error");
1481         }
1482         if (edma_err_cause & (EDMA_ERR_DEV_DCON | EDMA_ERR_DEV_CON)) {
1483                 ata_ehi_hotplugged(ehi);
1484                 ata_ehi_push_desc(ehi, edma_err_cause & EDMA_ERR_DEV_DCON ?
1485                         "dev disconnect" : "dev connect");
1486                 action |= ATA_EH_HARDRESET;
1487         }
1488
1489         if (IS_GEN_I(hpriv)) {
1490                 eh_freeze_mask = EDMA_EH_FREEZE_5;
1491
1492                 if (edma_err_cause & EDMA_ERR_SELF_DIS_5) {
1493                         struct mv_port_priv *pp = ap->private_data;
1494                         pp->pp_flags &= ~MV_PP_FLAG_EDMA_EN;
1495                         ata_ehi_push_desc(ehi, "EDMA self-disable");
1496                 }
1497         } else {
1498                 eh_freeze_mask = EDMA_EH_FREEZE;
1499
1500                 if (edma_err_cause & EDMA_ERR_SELF_DIS) {
1501                         struct mv_port_priv *pp = ap->private_data;
1502                         pp->pp_flags &= ~MV_PP_FLAG_EDMA_EN;
1503                         ata_ehi_push_desc(ehi, "EDMA self-disable");
1504                 }
1505
1506                 if (edma_err_cause & EDMA_ERR_SERR) {
1507                         sata_scr_read(&ap->link, SCR_ERROR, &serr);
1508                         sata_scr_write_flush(&ap->link, SCR_ERROR, serr);
1509                         err_mask = AC_ERR_ATA_BUS;
1510                         action |= ATA_EH_HARDRESET;
1511                 }
1512         }
1513
1514         /* Clear EDMA now that SERR cleanup done */
1515         writelfl(~edma_err_cause, port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
1516
1517         if (!err_mask) {
1518                 err_mask = AC_ERR_OTHER;
1519                 action |= ATA_EH_HARDRESET;
1520         }
1521
1522         ehi->serror |= serr;
1523         ehi->action |= action;
1524
1525         if (qc)
1526                 qc->err_mask |= err_mask;
1527         else
1528                 ehi->err_mask |= err_mask;
1529
1530         if (edma_err_cause & eh_freeze_mask)
1531                 ata_port_freeze(ap);
1532         else
1533                 ata_port_abort(ap);
1534 }
1535
1536 static void mv_intr_pio(struct ata_port *ap)
1537 {
1538         struct ata_queued_cmd *qc;
1539         u8 ata_status;
1540
1541         /* ignore spurious intr if drive still BUSY */
1542         ata_status = readb(ap->ioaddr.status_addr);
1543         if (unlikely(ata_status & ATA_BUSY))
1544                 return;
1545
1546         /* get active ATA command */
1547         qc = ata_qc_from_tag(ap, ap->link.active_tag);
1548         if (unlikely(!qc))                      /* no active tag */
1549                 return;
1550         if (qc->tf.flags & ATA_TFLAG_POLLING)   /* polling; we don't own qc */
1551                 return;
1552
1553         /* and finally, complete the ATA command */
1554         qc->err_mask |= ac_err_mask(ata_status);
1555         ata_qc_complete(qc);
1556 }
1557
1558 static void mv_intr_edma(struct ata_port *ap)
1559 {
1560         void __iomem *port_mmio = mv_ap_base(ap);
1561         struct mv_host_priv *hpriv = ap->host->private_data;
1562         struct mv_port_priv *pp = ap->private_data;
1563         struct ata_queued_cmd *qc;
1564         u32 out_index, in_index;
1565         bool work_done = false;
1566
1567         /* get h/w response queue pointer */
1568         in_index = (readl(port_mmio + EDMA_RSP_Q_IN_PTR_OFS)
1569                         >> EDMA_RSP_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK;
1570
1571         while (1) {
1572                 u16 status;
1573                 unsigned int tag;
1574
1575                 /* get s/w response queue last-read pointer, and compare */
1576                 out_index = pp->resp_idx & MV_MAX_Q_DEPTH_MASK;
1577                 if (in_index == out_index)
1578                         break;
1579
1580                 /* 50xx: get active ATA command */
1581                 if (IS_GEN_I(hpriv))
1582                         tag = ap->link.active_tag;
1583
1584                 /* Gen II/IIE: get active ATA command via tag, to enable
1585                  * support for queueing.  this works transparently for
1586                  * queued and non-queued modes.
1587                  */
1588                 else
1589                         tag = le16_to_cpu(pp->crpb[out_index].id) & 0x1f;
1590
1591                 qc = ata_qc_from_tag(ap, tag);
1592
1593                 /* lower 8 bits of status are EDMA_ERR_IRQ_CAUSE_OFS
1594                  * bits (WARNING: might not necessarily be associated
1595                  * with this command), which -should- be clear
1596                  * if all is well
1597                  */
1598                 status = le16_to_cpu(pp->crpb[out_index].flags);
1599                 if (unlikely(status & 0xff)) {
1600                         mv_err_intr(ap, qc);
1601                         return;
1602                 }
1603
1604                 /* and finally, complete the ATA command */
1605                 if (qc) {
1606                         qc->err_mask |=
1607                                 ac_err_mask(status >> CRPB_FLAG_STATUS_SHIFT);
1608                         ata_qc_complete(qc);
1609                 }
1610
1611                 /* advance software response queue pointer, to
1612                  * indicate (after the loop completes) to hardware
1613                  * that we have consumed a response queue entry.
1614                  */
1615                 work_done = true;
1616                 pp->resp_idx++;
1617         }
1618
1619         if (work_done)
1620                 writelfl((pp->crpb_dma & EDMA_RSP_Q_BASE_LO_MASK) |
1621                          (out_index << EDMA_RSP_Q_PTR_SHIFT),
1622                          port_mmio + EDMA_RSP_Q_OUT_PTR_OFS);
1623 }
1624
1625 /**
1626  *      mv_host_intr - Handle all interrupts on the given host controller
1627  *      @host: host specific structure
1628  *      @relevant: port error bits relevant to this host controller
1629  *      @hc: which host controller we're to look at
1630  *
1631  *      Read then write clear the HC interrupt status then walk each
1632  *      port connected to the HC and see if it needs servicing.  Port
1633  *      success ints are reported in the HC interrupt status reg, the
1634  *      port error ints are reported in the higher level main
1635  *      interrupt status register and thus are passed in via the
1636  *      'relevant' argument.
1637  *
1638  *      LOCKING:
1639  *      Inherited from caller.
1640  */
1641 static void mv_host_intr(struct ata_host *host, u32 relevant, unsigned int hc)
1642 {
1643         void __iomem *mmio = host->iomap[MV_PRIMARY_BAR];
1644         void __iomem *hc_mmio = mv_hc_base(mmio, hc);
1645         u32 hc_irq_cause;
1646         int port, port0;
1647
1648         if (hc == 0)
1649                 port0 = 0;
1650         else
1651                 port0 = MV_PORTS_PER_HC;
1652
1653         /* we'll need the HC success int register in most cases */
1654         hc_irq_cause = readl(hc_mmio + HC_IRQ_CAUSE_OFS);
1655         if (!hc_irq_cause)
1656                 return;
1657
1658         writelfl(~hc_irq_cause, hc_mmio + HC_IRQ_CAUSE_OFS);
1659
1660         VPRINTK("ENTER, hc%u relevant=0x%08x HC IRQ cause=0x%08x\n",
1661                 hc, relevant, hc_irq_cause);
1662
1663         for (port = port0; port < port0 + MV_PORTS_PER_HC; port++) {
1664                 struct ata_port *ap = host->ports[port];
1665                 struct mv_port_priv *pp = ap->private_data;
1666                 int have_err_bits, hard_port, shift;
1667
1668                 if ((!ap) || (ap->flags & ATA_FLAG_DISABLED))
1669                         continue;
1670
1671                 shift = port << 1;              /* (port * 2) */
1672                 if (port >= MV_PORTS_PER_HC) {
1673                         shift++;        /* skip bit 8 in the HC Main IRQ reg */
1674                 }
1675                 have_err_bits = ((PORT0_ERR << shift) & relevant);
1676
1677                 if (unlikely(have_err_bits)) {
1678                         struct ata_queued_cmd *qc;
1679
1680                         qc = ata_qc_from_tag(ap, ap->link.active_tag);
1681                         if (qc && (qc->tf.flags & ATA_TFLAG_POLLING))
1682                                 continue;
1683
1684                         mv_err_intr(ap, qc);
1685                         continue;
1686                 }
1687
1688                 hard_port = mv_hardport_from_port(port); /* range 0..3 */
1689
1690                 if (pp->pp_flags & MV_PP_FLAG_EDMA_EN) {
1691                         if ((CRPB_DMA_DONE << hard_port) & hc_irq_cause)
1692                                 mv_intr_edma(ap);
1693                 } else {
1694                         if ((DEV_IRQ << hard_port) & hc_irq_cause)
1695                                 mv_intr_pio(ap);
1696                 }
1697         }
1698         VPRINTK("EXIT\n");
1699 }
1700
1701 static void mv_pci_error(struct ata_host *host, void __iomem *mmio)
1702 {
1703         struct mv_host_priv *hpriv = host->private_data;
1704         struct ata_port *ap;
1705         struct ata_queued_cmd *qc;
1706         struct ata_eh_info *ehi;
1707         unsigned int i, err_mask, printed = 0;
1708         u32 err_cause;
1709
1710         err_cause = readl(mmio + hpriv->irq_cause_ofs);
1711
1712         dev_printk(KERN_ERR, host->dev, "PCI ERROR; PCI IRQ cause=0x%08x\n",
1713                    err_cause);
1714
1715         DPRINTK("All regs @ PCI error\n");
1716         mv_dump_all_regs(mmio, -1, to_pci_dev(host->dev));
1717
1718         writelfl(0, mmio + hpriv->irq_cause_ofs);
1719
1720         for (i = 0; i < host->n_ports; i++) {
1721                 ap = host->ports[i];
1722                 if (!ata_link_offline(&ap->link)) {
1723                         ehi = &ap->link.eh_info;
1724                         ata_ehi_clear_desc(ehi);
1725                         if (!printed++)
1726                                 ata_ehi_push_desc(ehi,
1727                                         "PCI err cause 0x%08x", err_cause);
1728                         err_mask = AC_ERR_HOST_BUS;
1729                         ehi->action = ATA_EH_HARDRESET;
1730                         qc = ata_qc_from_tag(ap, ap->link.active_tag);
1731                         if (qc)
1732                                 qc->err_mask |= err_mask;
1733                         else
1734                                 ehi->err_mask |= err_mask;
1735
1736                         ata_port_freeze(ap);
1737                 }
1738         }
1739 }
1740
1741 /**
1742  *      mv_interrupt - Main interrupt event handler
1743  *      @irq: unused
1744  *      @dev_instance: private data; in this case the host structure
1745  *
1746  *      Read the read only register to determine if any host
1747  *      controllers have pending interrupts.  If so, call lower level
1748  *      routine to handle.  Also check for PCI errors which are only
1749  *      reported here.
1750  *
1751  *      LOCKING:
1752  *      This routine holds the host lock while processing pending
1753  *      interrupts.
1754  */
1755 static irqreturn_t mv_interrupt(int irq, void *dev_instance)
1756 {
1757         struct ata_host *host = dev_instance;
1758         unsigned int hc, handled = 0, n_hcs;
1759         void __iomem *mmio = host->iomap[MV_PRIMARY_BAR];
1760         u32 irq_stat, irq_mask;
1761
1762         spin_lock(&host->lock);
1763         irq_stat = readl(mmio + HC_MAIN_IRQ_CAUSE_OFS);
1764         irq_mask = readl(mmio + HC_MAIN_IRQ_MASK_OFS);
1765
1766         /* check the cases where we either have nothing pending or have read
1767          * a bogus register value which can indicate HW removal or PCI fault
1768          */
1769         if (!(irq_stat & irq_mask) || (0xffffffffU == irq_stat))
1770                 goto out_unlock;
1771
1772         n_hcs = mv_get_hc_count(host->ports[0]->flags);
1773
1774         if (unlikely(irq_stat & PCI_ERR)) {
1775                 mv_pci_error(host, mmio);
1776                 handled = 1;
1777                 goto out_unlock;        /* skip all other HC irq handling */
1778         }
1779
1780         for (hc = 0; hc < n_hcs; hc++) {
1781                 u32 relevant = irq_stat & (HC0_IRQ_PEND << (hc * HC_SHIFT));
1782                 if (relevant) {
1783                         mv_host_intr(host, relevant, hc);
1784                         handled = 1;
1785                 }
1786         }
1787
1788 out_unlock:
1789         spin_unlock(&host->lock);
1790
1791         return IRQ_RETVAL(handled);
1792 }
1793
1794 static void __iomem *mv5_phy_base(void __iomem *mmio, unsigned int port)
1795 {
1796         void __iomem *hc_mmio = mv_hc_base_from_port(mmio, port);
1797         unsigned long ofs = (mv_hardport_from_port(port) + 1) * 0x100UL;
1798
1799         return hc_mmio + ofs;
1800 }
1801
1802 static unsigned int mv5_scr_offset(unsigned int sc_reg_in)
1803 {
1804         unsigned int ofs;
1805
1806         switch (sc_reg_in) {
1807         case SCR_STATUS:
1808         case SCR_ERROR:
1809         case SCR_CONTROL:
1810                 ofs = sc_reg_in * sizeof(u32);
1811                 break;
1812         default:
1813                 ofs = 0xffffffffU;
1814                 break;
1815         }
1816         return ofs;
1817 }
1818
1819 static int mv5_scr_read(struct ata_port *ap, unsigned int sc_reg_in, u32 *val)
1820 {
1821         void __iomem *mmio = ap->host->iomap[MV_PRIMARY_BAR];
1822         void __iomem *addr = mv5_phy_base(mmio, ap->port_no);
1823         unsigned int ofs = mv5_scr_offset(sc_reg_in);
1824
1825         if (ofs != 0xffffffffU) {
1826                 *val = readl(addr + ofs);
1827                 return 0;
1828         } else
1829                 return -EINVAL;
1830 }
1831
1832 static int mv5_scr_write(struct ata_port *ap, unsigned int sc_reg_in, u32 val)
1833 {
1834         void __iomem *mmio = ap->host->iomap[MV_PRIMARY_BAR];
1835         void __iomem *addr = mv5_phy_base(mmio, ap->port_no);
1836         unsigned int ofs = mv5_scr_offset(sc_reg_in);
1837
1838         if (ofs != 0xffffffffU) {
1839                 writelfl(val, addr + ofs);
1840                 return 0;
1841         } else
1842                 return -EINVAL;
1843 }
1844
1845 static void mv5_reset_bus(struct pci_dev *pdev, void __iomem *mmio)
1846 {
1847         int early_5080;
1848
1849         early_5080 = (pdev->device == 0x5080) && (pdev->revision == 0);
1850
1851         if (!early_5080) {
1852                 u32 tmp = readl(mmio + MV_PCI_EXP_ROM_BAR_CTL);
1853                 tmp |= (1 << 0);
1854                 writel(tmp, mmio + MV_PCI_EXP_ROM_BAR_CTL);
1855         }
1856
1857         mv_reset_pci_bus(pdev, mmio);
1858 }
1859
1860 static void mv5_reset_flash(struct mv_host_priv *hpriv, void __iomem *mmio)
1861 {
1862         writel(0x0fcfffff, mmio + MV_FLASH_CTL);
1863 }
1864
1865 static void mv5_read_preamp(struct mv_host_priv *hpriv, int idx,
1866                            void __iomem *mmio)
1867 {
1868         void __iomem *phy_mmio = mv5_phy_base(mmio, idx);
1869         u32 tmp;
1870
1871         tmp = readl(phy_mmio + MV5_PHY_MODE);
1872
1873         hpriv->signal[idx].pre = tmp & 0x1800;  /* bits 12:11 */
1874         hpriv->signal[idx].amps = tmp & 0xe0;   /* bits 7:5 */
1875 }
1876
1877 static void mv5_enable_leds(struct mv_host_priv *hpriv, void __iomem *mmio)
1878 {
1879         u32 tmp;
1880
1881         writel(0, mmio + MV_GPIO_PORT_CTL);
1882
1883         /* FIXME: handle MV_HP_ERRATA_50XXB2 errata */
1884
1885         tmp = readl(mmio + MV_PCI_EXP_ROM_BAR_CTL);
1886         tmp |= ~(1 << 0);
1887         writel(tmp, mmio + MV_PCI_EXP_ROM_BAR_CTL);
1888 }
1889
1890 static void mv5_phy_errata(struct mv_host_priv *hpriv, void __iomem *mmio,
1891                            unsigned int port)
1892 {
1893         void __iomem *phy_mmio = mv5_phy_base(mmio, port);
1894         const u32 mask = (1<<12) | (1<<11) | (1<<7) | (1<<6) | (1<<5);
1895         u32 tmp;
1896         int fix_apm_sq = (hpriv->hp_flags & MV_HP_ERRATA_50XXB0);
1897
1898         if (fix_apm_sq) {
1899                 tmp = readl(phy_mmio + MV5_LT_MODE);
1900                 tmp |= (1 << 19);
1901                 writel(tmp, phy_mmio + MV5_LT_MODE);
1902
1903                 tmp = readl(phy_mmio + MV5_PHY_CTL);
1904                 tmp &= ~0x3;
1905                 tmp |= 0x1;
1906                 writel(tmp, phy_mmio + MV5_PHY_CTL);
1907         }
1908
1909         tmp = readl(phy_mmio + MV5_PHY_MODE);
1910         tmp &= ~mask;
1911         tmp |= hpriv->signal[port].pre;
1912         tmp |= hpriv->signal[port].amps;
1913         writel(tmp, phy_mmio + MV5_PHY_MODE);
1914 }
1915
1916
1917 #undef ZERO
1918 #define ZERO(reg) writel(0, port_mmio + (reg))
1919 static void mv5_reset_hc_port(struct mv_host_priv *hpriv, void __iomem *mmio,
1920                              unsigned int port)
1921 {
1922         void __iomem *port_mmio = mv_port_base(mmio, port);
1923
1924         writelfl(EDMA_DS, port_mmio + EDMA_CMD_OFS);
1925
1926         mv_channel_reset(hpriv, mmio, port);
1927
1928         ZERO(0x028);    /* command */
1929         writel(0x11f, port_mmio + EDMA_CFG_OFS);
1930         ZERO(0x004);    /* timer */
1931         ZERO(0x008);    /* irq err cause */
1932         ZERO(0x00c);    /* irq err mask */
1933         ZERO(0x010);    /* rq bah */
1934         ZERO(0x014);    /* rq inp */
1935         ZERO(0x018);    /* rq outp */
1936         ZERO(0x01c);    /* respq bah */
1937         ZERO(0x024);    /* respq outp */
1938         ZERO(0x020);    /* respq inp */
1939         ZERO(0x02c);    /* test control */
1940         writel(0xbc, port_mmio + EDMA_IORDY_TMOUT);
1941 }
1942 #undef ZERO
1943
1944 #define ZERO(reg) writel(0, hc_mmio + (reg))
1945 static void mv5_reset_one_hc(struct mv_host_priv *hpriv, void __iomem *mmio,
1946                         unsigned int hc)
1947 {
1948         void __iomem *hc_mmio = mv_hc_base(mmio, hc);
1949         u32 tmp;
1950
1951         ZERO(0x00c);
1952         ZERO(0x010);
1953         ZERO(0x014);
1954         ZERO(0x018);
1955
1956         tmp = readl(hc_mmio + 0x20);
1957         tmp &= 0x1c1c1c1c;
1958         tmp |= 0x03030303;
1959         writel(tmp, hc_mmio + 0x20);
1960 }
1961 #undef ZERO
1962
1963 static int mv5_reset_hc(struct mv_host_priv *hpriv, void __iomem *mmio,
1964                         unsigned int n_hc)
1965 {
1966         unsigned int hc, port;
1967
1968         for (hc = 0; hc < n_hc; hc++) {
1969                 for (port = 0; port < MV_PORTS_PER_HC; port++)
1970                         mv5_reset_hc_port(hpriv, mmio,
1971                                           (hc * MV_PORTS_PER_HC) + port);
1972
1973                 mv5_reset_one_hc(hpriv, mmio, hc);
1974         }
1975
1976         return 0;
1977 }
1978
1979 #undef ZERO
1980 #define ZERO(reg) writel(0, mmio + (reg))
1981 static void mv_reset_pci_bus(struct pci_dev *pdev, void __iomem *mmio)
1982 {
1983         struct ata_host     *host = dev_get_drvdata(&pdev->dev);
1984         struct mv_host_priv *hpriv = host->private_data;
1985         u32 tmp;
1986
1987         tmp = readl(mmio + MV_PCI_MODE);
1988         tmp &= 0xff00ffff;
1989         writel(tmp, mmio + MV_PCI_MODE);
1990
1991         ZERO(MV_PCI_DISC_TIMER);
1992         ZERO(MV_PCI_MSI_TRIGGER);
1993         writel(0x000100ff, mmio + MV_PCI_XBAR_TMOUT);
1994         ZERO(HC_MAIN_IRQ_MASK_OFS);
1995         ZERO(MV_PCI_SERR_MASK);
1996         ZERO(hpriv->irq_cause_ofs);
1997         ZERO(hpriv->irq_mask_ofs);
1998         ZERO(MV_PCI_ERR_LOW_ADDRESS);
1999         ZERO(MV_PCI_ERR_HIGH_ADDRESS);
2000         ZERO(MV_PCI_ERR_ATTRIBUTE);
2001         ZERO(MV_PCI_ERR_COMMAND);
2002 }
2003 #undef ZERO
2004
2005 static void mv6_reset_flash(struct mv_host_priv *hpriv, void __iomem *mmio)
2006 {
2007         u32 tmp;
2008
2009         mv5_reset_flash(hpriv, mmio);
2010
2011         tmp = readl(mmio + MV_GPIO_PORT_CTL);
2012         tmp &= 0x3;
2013         tmp |= (1 << 5) | (1 << 6);
2014         writel(tmp, mmio + MV_GPIO_PORT_CTL);
2015 }
2016
2017 /**
2018  *      mv6_reset_hc - Perform the 6xxx global soft reset
2019  *      @mmio: base address of the HBA
2020  *
2021  *      This routine only applies to 6xxx parts.
2022  *
2023  *      LOCKING:
2024  *      Inherited from caller.
2025  */
2026 static int mv6_reset_hc(struct mv_host_priv *hpriv, void __iomem *mmio,
2027                         unsigned int n_hc)
2028 {
2029         void __iomem *reg = mmio + PCI_MAIN_CMD_STS_OFS;
2030         int i, rc = 0;
2031         u32 t;
2032
2033         /* Following procedure defined in PCI "main command and status
2034          * register" table.
2035          */
2036         t = readl(reg);
2037         writel(t | STOP_PCI_MASTER, reg);
2038
2039         for (i = 0; i < 1000; i++) {
2040                 udelay(1);
2041                 t = readl(reg);
2042                 if (PCI_MASTER_EMPTY & t)
2043                         break;
2044         }
2045         if (!(PCI_MASTER_EMPTY & t)) {
2046                 printk(KERN_ERR DRV_NAME ": PCI master won't flush\n");
2047                 rc = 1;
2048                 goto done;
2049         }
2050
2051         /* set reset */
2052         i = 5;
2053         do {
2054                 writel(t | GLOB_SFT_RST, reg);
2055                 t = readl(reg);
2056                 udelay(1);
2057         } while (!(GLOB_SFT_RST & t) && (i-- > 0));
2058
2059         if (!(GLOB_SFT_RST & t)) {
2060                 printk(KERN_ERR DRV_NAME ": can't set global reset\n");
2061                 rc = 1;
2062                 goto done;
2063         }
2064
2065         /* clear reset and *reenable the PCI master* (not mentioned in spec) */
2066         i = 5;
2067         do {
2068                 writel(t & ~(GLOB_SFT_RST | STOP_PCI_MASTER), reg);
2069                 t = readl(reg);
2070                 udelay(1);
2071         } while ((GLOB_SFT_RST & t) && (i-- > 0));
2072
2073         if (GLOB_SFT_RST & t) {
2074                 printk(KERN_ERR DRV_NAME ": can't clear global reset\n");
2075                 rc = 1;
2076         }
2077 done:
2078         return rc;
2079 }
2080
2081 static void mv6_read_preamp(struct mv_host_priv *hpriv, int idx,
2082                            void __iomem *mmio)
2083 {
2084         void __iomem *port_mmio;
2085         u32 tmp;
2086
2087         tmp = readl(mmio + MV_RESET_CFG);
2088         if ((tmp & (1 << 0)) == 0) {
2089                 hpriv->signal[idx].amps = 0x7 << 8;
2090                 hpriv->signal[idx].pre = 0x1 << 5;
2091                 return;
2092         }
2093
2094         port_mmio = mv_port_base(mmio, idx);
2095         tmp = readl(port_mmio + PHY_MODE2);
2096
2097         hpriv->signal[idx].amps = tmp & 0x700;  /* bits 10:8 */
2098         hpriv->signal[idx].pre = tmp & 0xe0;    /* bits 7:5 */
2099 }
2100
2101 static void mv6_enable_leds(struct mv_host_priv *hpriv, void __iomem *mmio)
2102 {
2103         writel(0x00000060, mmio + MV_GPIO_PORT_CTL);
2104 }
2105
2106 static void mv6_phy_errata(struct mv_host_priv *hpriv, void __iomem *mmio,
2107                            unsigned int port)
2108 {
2109         void __iomem *port_mmio = mv_port_base(mmio, port);
2110
2111         u32 hp_flags = hpriv->hp_flags;
2112         int fix_phy_mode2 =
2113                 hp_flags & (MV_HP_ERRATA_60X1B2 | MV_HP_ERRATA_60X1C0);
2114         int fix_phy_mode4 =
2115                 hp_flags & (MV_HP_ERRATA_60X1B2 | MV_HP_ERRATA_60X1C0);
2116         u32 m2, tmp;
2117
2118         if (fix_phy_mode2) {
2119                 m2 = readl(port_mmio + PHY_MODE2);
2120                 m2 &= ~(1 << 16);
2121                 m2 |= (1 << 31);
2122                 writel(m2, port_mmio + PHY_MODE2);
2123
2124                 udelay(200);
2125
2126                 m2 = readl(port_mmio + PHY_MODE2);
2127                 m2 &= ~((1 << 16) | (1 << 31));
2128                 writel(m2, port_mmio + PHY_MODE2);
2129
2130                 udelay(200);
2131         }
2132
2133         /* who knows what this magic does */
2134         tmp = readl(port_mmio + PHY_MODE3);
2135         tmp &= ~0x7F800000;
2136         tmp |= 0x2A800000;
2137         writel(tmp, port_mmio + PHY_MODE3);
2138
2139         if (fix_phy_mode4) {
2140                 u32 m4;
2141
2142                 m4 = readl(port_mmio + PHY_MODE4);
2143
2144                 if (hp_flags & MV_HP_ERRATA_60X1B2)
2145                         tmp = readl(port_mmio + 0x310);
2146
2147                 m4 = (m4 & ~(1 << 1)) | (1 << 0);
2148
2149                 writel(m4, port_mmio + PHY_MODE4);
2150
2151                 if (hp_flags & MV_HP_ERRATA_60X1B2)
2152                         writel(tmp, port_mmio + 0x310);
2153         }
2154
2155         /* Revert values of pre-emphasis and signal amps to the saved ones */
2156         m2 = readl(port_mmio + PHY_MODE2);
2157
2158         m2 &= ~MV_M2_PREAMP_MASK;
2159         m2 |= hpriv->signal[port].amps;
2160         m2 |= hpriv->signal[port].pre;
2161         m2 &= ~(1 << 16);
2162
2163         /* according to mvSata 3.6.1, some IIE values are fixed */
2164         if (IS_GEN_IIE(hpriv)) {
2165                 m2 &= ~0xC30FF01F;
2166                 m2 |= 0x0000900F;
2167         }
2168
2169         writel(m2, port_mmio + PHY_MODE2);
2170 }
2171
2172 static void mv_channel_reset(struct mv_host_priv *hpriv, void __iomem *mmio,
2173                              unsigned int port_no)
2174 {
2175         void __iomem *port_mmio = mv_port_base(mmio, port_no);
2176
2177         writelfl(ATA_RST, port_mmio + EDMA_CMD_OFS);
2178
2179         if (IS_GEN_II(hpriv)) {
2180                 u32 ifctl = readl(port_mmio + SATA_INTERFACE_CTL);
2181                 ifctl |= (1 << 7);              /* enable gen2i speed */
2182                 ifctl = (ifctl & 0xfff) | 0x9b1000; /* from chip spec */
2183                 writelfl(ifctl, port_mmio + SATA_INTERFACE_CTL);
2184         }
2185
2186         udelay(25);             /* allow reset propagation */
2187
2188         /* Spec never mentions clearing the bit.  Marvell's driver does
2189          * clear the bit, however.
2190          */
2191         writelfl(0, port_mmio + EDMA_CMD_OFS);
2192
2193         hpriv->ops->phy_errata(hpriv, mmio, port_no);
2194
2195         if (IS_GEN_I(hpriv))
2196                 mdelay(1);
2197 }
2198
2199 /**
2200  *      mv_phy_reset - Perform eDMA reset followed by COMRESET
2201  *      @ap: ATA channel to manipulate
2202  *
2203  *      Part of this is taken from __sata_phy_reset and modified to
2204  *      not sleep since this routine gets called from interrupt level.
2205  *
2206  *      LOCKING:
2207  *      Inherited from caller.  This is coded to safe to call at
2208  *      interrupt level, i.e. it does not sleep.
2209  */
2210 static void mv_phy_reset(struct ata_port *ap, unsigned int *class,
2211                          unsigned long deadline)
2212 {
2213         struct mv_port_priv *pp = ap->private_data;
2214         struct mv_host_priv *hpriv = ap->host->private_data;
2215         void __iomem *port_mmio = mv_ap_base(ap);
2216         int retry = 5;
2217         u32 sstatus;
2218
2219         VPRINTK("ENTER, port %u, mmio 0x%p\n", ap->port_no, port_mmio);
2220
2221 #ifdef DEBUG
2222         {
2223                 u32 sstatus, serror, scontrol;
2224
2225                 mv_scr_read(ap, SCR_STATUS, &sstatus);
2226                 mv_scr_read(ap, SCR_ERROR, &serror);
2227                 mv_scr_read(ap, SCR_CONTROL, &scontrol);
2228                 DPRINTK("S-regs after ATA_RST: SStat 0x%08x SErr 0x%08x "
2229                         "SCtrl 0x%08x\n", sstatus, serror, scontrol);
2230         }
2231 #endif
2232
2233         /* Issue COMRESET via SControl */
2234 comreset_retry:
2235         sata_scr_write_flush(&ap->link, SCR_CONTROL, 0x301);
2236         msleep(1);
2237
2238         sata_scr_write_flush(&ap->link, SCR_CONTROL, 0x300);
2239         msleep(20);
2240
2241         do {
2242                 sata_scr_read(&ap->link, SCR_STATUS, &sstatus);
2243                 if (((sstatus & 0x3) == 3) || ((sstatus & 0x3) == 0))
2244                         break;
2245
2246                 msleep(1);
2247         } while (time_before(jiffies, deadline));
2248
2249         /* work around errata */
2250         if (IS_GEN_II(hpriv) &&
2251             (sstatus != 0x0) && (sstatus != 0x113) && (sstatus != 0x123) &&
2252             (retry-- > 0))
2253                 goto comreset_retry;
2254
2255 #ifdef DEBUG
2256         {
2257                 u32 sstatus, serror, scontrol;
2258
2259                 mv_scr_read(ap, SCR_STATUS, &sstatus);
2260                 mv_scr_read(ap, SCR_ERROR, &serror);
2261                 mv_scr_read(ap, SCR_CONTROL, &scontrol);
2262                 DPRINTK("S-regs after PHY wake: SStat 0x%08x SErr 0x%08x "
2263                         "SCtrl 0x%08x\n", sstatus, serror, scontrol);
2264         }
2265 #endif
2266
2267         if (ata_link_offline(&ap->link)) {
2268                 *class = ATA_DEV_NONE;
2269                 return;
2270         }
2271
2272         /* even after SStatus reflects that device is ready,
2273          * it seems to take a while for link to be fully
2274          * established (and thus Status no longer 0x80/0x7F),
2275          * so we poll a bit for that, here.
2276          */
2277         retry = 20;
2278         while (1) {
2279                 u8 drv_stat = ata_check_status(ap);
2280                 if ((drv_stat != 0x80) && (drv_stat != 0x7f))
2281                         break;
2282                 msleep(500);
2283                 if (retry-- <= 0)
2284                         break;
2285                 if (time_after(jiffies, deadline))
2286                         break;
2287         }
2288
2289         /* FIXME: if we passed the deadline, the following
2290          * code probably produces an invalid result
2291          */
2292
2293         /* finally, read device signature from TF registers */
2294         *class = ata_dev_try_classify(ap->link.device, 1, NULL);
2295
2296         writelfl(0, port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
2297
2298         WARN_ON(pp->pp_flags & MV_PP_FLAG_EDMA_EN);
2299
2300         VPRINTK("EXIT\n");
2301 }
2302
2303 static int mv_prereset(struct ata_link *link, unsigned long deadline)
2304 {
2305         struct ata_port *ap = link->ap;
2306         struct mv_port_priv *pp = ap->private_data;
2307         struct ata_eh_context *ehc = &link->eh_context;
2308         int rc;
2309
2310         rc = mv_stop_dma(ap);
2311         if (rc)
2312                 ehc->i.action |= ATA_EH_HARDRESET;
2313
2314         if (!(pp->pp_flags & MV_PP_FLAG_HAD_A_RESET)) {
2315                 pp->pp_flags |= MV_PP_FLAG_HAD_A_RESET;
2316                 ehc->i.action |= ATA_EH_HARDRESET;
2317         }
2318
2319         /* if we're about to do hardreset, nothing more to do */
2320         if (ehc->i.action & ATA_EH_HARDRESET)
2321                 return 0;
2322
2323         if (ata_link_online(link))
2324                 rc = ata_wait_ready(ap, deadline);
2325         else
2326                 rc = -ENODEV;
2327
2328         return rc;
2329 }
2330
2331 static int mv_hardreset(struct ata_link *link, unsigned int *class,
2332                         unsigned long deadline)
2333 {
2334         struct ata_port *ap = link->ap;
2335         struct mv_host_priv *hpriv = ap->host->private_data;
2336         void __iomem *mmio = ap->host->iomap[MV_PRIMARY_BAR];
2337
2338         mv_stop_dma(ap);
2339
2340         mv_channel_reset(hpriv, mmio, ap->port_no);
2341
2342         mv_phy_reset(ap, class, deadline);
2343
2344         return 0;
2345 }
2346
2347 static void mv_postreset(struct ata_link *link, unsigned int *classes)
2348 {
2349         struct ata_port *ap = link->ap;
2350         u32 serr;
2351
2352         /* print link status */
2353         sata_print_link_status(link);
2354
2355         /* clear SError */
2356         sata_scr_read(link, SCR_ERROR, &serr);
2357         sata_scr_write_flush(link, SCR_ERROR, serr);
2358
2359         /* bail out if no device is present */
2360         if (classes[0] == ATA_DEV_NONE && classes[1] == ATA_DEV_NONE) {
2361                 DPRINTK("EXIT, no device\n");
2362                 return;
2363         }
2364
2365         /* set up device control */
2366         iowrite8(ap->ctl, ap->ioaddr.ctl_addr);
2367 }
2368
2369 static void mv_error_handler(struct ata_port *ap)
2370 {
2371         ata_do_eh(ap, mv_prereset, ata_std_softreset,
2372                   mv_hardreset, mv_postreset);
2373 }
2374
2375 static void mv_post_int_cmd(struct ata_queued_cmd *qc)
2376 {
2377         mv_stop_dma(qc->ap);
2378 }
2379
2380 static void mv_eh_freeze(struct ata_port *ap)
2381 {
2382         void __iomem *mmio = ap->host->iomap[MV_PRIMARY_BAR];
2383         unsigned int hc = (ap->port_no > 3) ? 1 : 0;
2384         u32 tmp, mask;
2385         unsigned int shift;
2386
2387         /* FIXME: handle coalescing completion events properly */
2388
2389         shift = ap->port_no * 2;
2390         if (hc > 0)
2391                 shift++;
2392
2393         mask = 0x3 << shift;
2394
2395         /* disable assertion of portN err, done events */
2396         tmp = readl(mmio + HC_MAIN_IRQ_MASK_OFS);
2397         writelfl(tmp & ~mask, mmio + HC_MAIN_IRQ_MASK_OFS);
2398 }
2399
2400 static void mv_eh_thaw(struct ata_port *ap)
2401 {
2402         void __iomem *mmio = ap->host->iomap[MV_PRIMARY_BAR];
2403         unsigned int hc = (ap->port_no > 3) ? 1 : 0;
2404         void __iomem *hc_mmio = mv_hc_base(mmio, hc);
2405         void __iomem *port_mmio = mv_ap_base(ap);
2406         u32 tmp, mask, hc_irq_cause;
2407         unsigned int shift, hc_port_no = ap->port_no;
2408
2409         /* FIXME: handle coalescing completion events properly */
2410
2411         shift = ap->port_no * 2;
2412         if (hc > 0) {
2413                 shift++;
2414                 hc_port_no -= 4;
2415         }
2416
2417         mask = 0x3 << shift;
2418
2419         /* clear EDMA errors on this port */
2420         writel(0, port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
2421
2422         /* clear pending irq events */
2423         hc_irq_cause = readl(hc_mmio + HC_IRQ_CAUSE_OFS);
2424         hc_irq_cause &= ~(1 << hc_port_no);     /* clear CRPB-done */
2425         hc_irq_cause &= ~(1 << (hc_port_no + 8)); /* clear Device int */
2426         writel(hc_irq_cause, hc_mmio + HC_IRQ_CAUSE_OFS);
2427
2428         /* enable assertion of portN err, done events */
2429         tmp = readl(mmio + HC_MAIN_IRQ_MASK_OFS);
2430         writelfl(tmp | mask, mmio + HC_MAIN_IRQ_MASK_OFS);
2431 }
2432
2433 /**
2434  *      mv_port_init - Perform some early initialization on a single port.
2435  *      @port: libata data structure storing shadow register addresses
2436  *      @port_mmio: base address of the port
2437  *
2438  *      Initialize shadow register mmio addresses, clear outstanding
2439  *      interrupts on the port, and unmask interrupts for the future
2440  *      start of the port.
2441  *
2442  *      LOCKING:
2443  *      Inherited from caller.
2444  */
2445 static void mv_port_init(struct ata_ioports *port,  void __iomem *port_mmio)
2446 {
2447         void __iomem *shd_base = port_mmio + SHD_BLK_OFS;
2448         unsigned serr_ofs;
2449
2450         /* PIO related setup
2451          */
2452         port->data_addr = shd_base + (sizeof(u32) * ATA_REG_DATA);
2453         port->error_addr =
2454                 port->feature_addr = shd_base + (sizeof(u32) * ATA_REG_ERR);
2455         port->nsect_addr = shd_base + (sizeof(u32) * ATA_REG_NSECT);
2456         port->lbal_addr = shd_base + (sizeof(u32) * ATA_REG_LBAL);
2457         port->lbam_addr = shd_base + (sizeof(u32) * ATA_REG_LBAM);
2458         port->lbah_addr = shd_base + (sizeof(u32) * ATA_REG_LBAH);
2459         port->device_addr = shd_base + (sizeof(u32) * ATA_REG_DEVICE);
2460         port->status_addr =
2461                 port->command_addr = shd_base + (sizeof(u32) * ATA_REG_STATUS);
2462         /* special case: control/altstatus doesn't have ATA_REG_ address */
2463         port->altstatus_addr = port->ctl_addr = shd_base + SHD_CTL_AST_OFS;
2464
2465         /* unused: */
2466         port->cmd_addr = port->bmdma_addr = port->scr_addr = NULL;
2467
2468         /* Clear any currently outstanding port interrupt conditions */
2469         serr_ofs = mv_scr_offset(SCR_ERROR);
2470         writelfl(readl(port_mmio + serr_ofs), port_mmio + serr_ofs);
2471         writelfl(0, port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
2472
2473         /* unmask all non-transient EDMA error interrupts */
2474         writelfl(~EDMA_ERR_IRQ_TRANSIENT, port_mmio + EDMA_ERR_IRQ_MASK_OFS);
2475
2476         VPRINTK("EDMA cfg=0x%08x EDMA IRQ err cause/mask=0x%08x/0x%08x\n",
2477                 readl(port_mmio + EDMA_CFG_OFS),
2478                 readl(port_mmio + EDMA_ERR_IRQ_CAUSE_OFS),
2479                 readl(port_mmio + EDMA_ERR_IRQ_MASK_OFS));
2480 }
2481
2482 static int mv_chip_id(struct ata_host *host, unsigned int board_idx)
2483 {
2484         struct pci_dev *pdev = to_pci_dev(host->dev);
2485         struct mv_host_priv *hpriv = host->private_data;
2486         u32 hp_flags = hpriv->hp_flags;
2487
2488         switch (board_idx) {
2489         case chip_5080:
2490                 hpriv->ops = &mv5xxx_ops;
2491                 hp_flags |= MV_HP_GEN_I;
2492
2493                 switch (pdev->revision) {
2494                 case 0x1:
2495                         hp_flags |= MV_HP_ERRATA_50XXB0;
2496                         break;
2497                 case 0x3:
2498                         hp_flags |= MV_HP_ERRATA_50XXB2;
2499                         break;
2500                 default:
2501                         dev_printk(KERN_WARNING, &pdev->dev,
2502                            "Applying 50XXB2 workarounds to unknown rev\n");
2503                         hp_flags |= MV_HP_ERRATA_50XXB2;
2504                         break;
2505                 }
2506                 break;
2507
2508         case chip_504x:
2509         case chip_508x:
2510                 hpriv->ops = &mv5xxx_ops;
2511                 hp_flags |= MV_HP_GEN_I;
2512
2513                 switch (pdev->revision) {
2514                 case 0x0:
2515                         hp_flags |= MV_HP_ERRATA_50XXB0;
2516                         break;
2517                 case 0x3:
2518                         hp_flags |= MV_HP_ERRATA_50XXB2;
2519                         break;
2520                 default:
2521                         dev_printk(KERN_WARNING, &pdev->dev,
2522                            "Applying B2 workarounds to unknown rev\n");
2523                         hp_flags |= MV_HP_ERRATA_50XXB2;
2524                         break;
2525                 }
2526                 break;
2527
2528         case chip_604x:
2529         case chip_608x:
2530                 hpriv->ops = &mv6xxx_ops;
2531                 hp_flags |= MV_HP_GEN_II;
2532
2533                 switch (pdev->revision) {
2534                 case 0x7:
2535                         hp_flags |= MV_HP_ERRATA_60X1B2;
2536                         break;
2537                 case 0x9:
2538                         hp_flags |= MV_HP_ERRATA_60X1C0;
2539                         break;
2540                 default:
2541                         dev_printk(KERN_WARNING, &pdev->dev,
2542                                    "Applying B2 workarounds to unknown rev\n");
2543                         hp_flags |= MV_HP_ERRATA_60X1B2;
2544                         break;
2545                 }
2546                 break;
2547
2548         case chip_7042:
2549                 hp_flags |= MV_HP_PCIE;
2550                 if (pdev->vendor == PCI_VENDOR_ID_TTI &&
2551                     (pdev->device == 0x2300 || pdev->device == 0x2310))
2552                 {
2553                         /*
2554                          * Highpoint RocketRAID PCIe 23xx series cards:
2555                          *
2556                          * Unconfigured drives are treated as "Legacy"
2557                          * by the BIOS, and it overwrites sector 8 with
2558                          * a "Lgcy" metadata block prior to Linux boot.
2559                          *
2560                          * Configured drives (RAID or JBOD) leave sector 8
2561                          * alone, but instead overwrite a high numbered
2562                          * sector for the RAID metadata.  This sector can
2563                          * be determined exactly, by truncating the physical
2564                          * drive capacity to a nice even GB value.
2565                          *
2566                          * RAID metadata is at: (dev->n_sectors & ~0xfffff)
2567                          *
2568                          * Warn the user, lest they think we're just buggy.
2569                          */
2570                         printk(KERN_WARNING DRV_NAME ": Highpoint RocketRAID"
2571                                 " BIOS CORRUPTS DATA on all attached drives,"
2572                                 " regardless of if/how they are configured."
2573                                 " BEWARE!\n");
2574                         printk(KERN_WARNING DRV_NAME ": For data safety, do not"
2575                                 " use sectors 8-9 on \"Legacy\" drives,"
2576                                 " and avoid the final two gigabytes on"
2577                                 " all RocketRAID BIOS initialized drives.\n");
2578                 }
2579         case chip_6042:
2580                 hpriv->ops = &mv6xxx_ops;
2581                 hp_flags |= MV_HP_GEN_IIE;
2582
2583                 switch (pdev->revision) {
2584                 case 0x0:
2585                         hp_flags |= MV_HP_ERRATA_XX42A0;
2586                         break;
2587                 case 0x1:
2588                         hp_flags |= MV_HP_ERRATA_60X1C0;
2589                         break;
2590                 default:
2591                         dev_printk(KERN_WARNING, &pdev->dev,
2592                            "Applying 60X1C0 workarounds to unknown rev\n");
2593                         hp_flags |= MV_HP_ERRATA_60X1C0;
2594                         break;
2595                 }
2596                 break;
2597
2598         default:
2599                 dev_printk(KERN_ERR, &pdev->dev,
2600                            "BUG: invalid board index %u\n", board_idx);
2601                 return 1;
2602         }
2603
2604         hpriv->hp_flags = hp_flags;
2605         if (hp_flags & MV_HP_PCIE) {
2606                 hpriv->irq_cause_ofs    = PCIE_IRQ_CAUSE_OFS;
2607                 hpriv->irq_mask_ofs     = PCIE_IRQ_MASK_OFS;
2608                 hpriv->unmask_all_irqs  = PCIE_UNMASK_ALL_IRQS;
2609         } else {
2610                 hpriv->irq_cause_ofs    = PCI_IRQ_CAUSE_OFS;
2611                 hpriv->irq_mask_ofs     = PCI_IRQ_MASK_OFS;
2612                 hpriv->unmask_all_irqs  = PCI_UNMASK_ALL_IRQS;
2613         }
2614
2615         return 0;
2616 }
2617
2618 /**
2619  *      mv_init_host - Perform some early initialization of the host.
2620  *      @host: ATA host to initialize
2621  *      @board_idx: controller index
2622  *
2623  *      If possible, do an early global reset of the host.  Then do
2624  *      our port init and clear/unmask all/relevant host interrupts.
2625  *
2626  *      LOCKING:
2627  *      Inherited from caller.
2628  */
2629 static int mv_init_host(struct ata_host *host, unsigned int board_idx)
2630 {
2631         int rc = 0, n_hc, port, hc;
2632         struct pci_dev *pdev = to_pci_dev(host->dev);
2633         void __iomem *mmio = host->iomap[MV_PRIMARY_BAR];
2634         struct mv_host_priv *hpriv = host->private_data;
2635
2636         /* global interrupt mask */
2637         writel(0, mmio + HC_MAIN_IRQ_MASK_OFS);
2638
2639         rc = mv_chip_id(host, board_idx);
2640         if (rc)
2641                 goto done;
2642
2643         n_hc = mv_get_hc_count(host->ports[0]->flags);
2644
2645         for (port = 0; port < host->n_ports; port++)
2646                 hpriv->ops->read_preamp(hpriv, port, mmio);
2647
2648         rc = hpriv->ops->reset_hc(hpriv, mmio, n_hc);
2649         if (rc)
2650                 goto done;
2651
2652         hpriv->ops->reset_flash(hpriv, mmio);
2653         hpriv->ops->reset_bus(pdev, mmio);
2654         hpriv->ops->enable_leds(hpriv, mmio);
2655
2656         for (port = 0; port < host->n_ports; port++) {
2657                 if (IS_GEN_II(hpriv)) {
2658                         void __iomem *port_mmio = mv_port_base(mmio, port);
2659
2660                         u32 ifctl = readl(port_mmio + SATA_INTERFACE_CTL);
2661                         ifctl |= (1 << 7);              /* enable gen2i speed */
2662                         ifctl = (ifctl & 0xfff) | 0x9b1000; /* from chip spec */
2663                         writelfl(ifctl, port_mmio + SATA_INTERFACE_CTL);
2664                 }
2665
2666                 hpriv->ops->phy_errata(hpriv, mmio, port);
2667         }
2668
2669         for (port = 0; port < host->n_ports; port++) {
2670                 struct ata_port *ap = host->ports[port];
2671                 void __iomem *port_mmio = mv_port_base(mmio, port);
2672                 unsigned int offset = port_mmio - mmio;
2673
2674                 mv_port_init(&ap->ioaddr, port_mmio);
2675
2676                 ata_port_pbar_desc(ap, MV_PRIMARY_BAR, -1, "mmio");
2677                 ata_port_pbar_desc(ap, MV_PRIMARY_BAR, offset, "port");
2678         }
2679
2680         for (hc = 0; hc < n_hc; hc++) {
2681                 void __iomem *hc_mmio = mv_hc_base(mmio, hc);
2682
2683                 VPRINTK("HC%i: HC config=0x%08x HC IRQ cause "
2684                         "(before clear)=0x%08x\n", hc,
2685                         readl(hc_mmio + HC_CFG_OFS),
2686                         readl(hc_mmio + HC_IRQ_CAUSE_OFS));
2687
2688                 /* Clear any currently outstanding hc interrupt conditions */
2689                 writelfl(0, hc_mmio + HC_IRQ_CAUSE_OFS);
2690         }
2691
2692         /* Clear any currently outstanding host interrupt conditions */
2693         writelfl(0, mmio + hpriv->irq_cause_ofs);
2694
2695         /* and unmask interrupt generation for host regs */
2696         writelfl(hpriv->unmask_all_irqs, mmio + hpriv->irq_mask_ofs);
2697
2698         if (IS_GEN_I(hpriv))
2699                 writelfl(~HC_MAIN_MASKED_IRQS_5, mmio + HC_MAIN_IRQ_MASK_OFS);
2700         else
2701                 writelfl(~HC_MAIN_MASKED_IRQS, mmio + HC_MAIN_IRQ_MASK_OFS);
2702
2703         VPRINTK("HC MAIN IRQ cause/mask=0x%08x/0x%08x "
2704                 "PCI int cause/mask=0x%08x/0x%08x\n",
2705                 readl(mmio + HC_MAIN_IRQ_CAUSE_OFS),
2706                 readl(mmio + HC_MAIN_IRQ_MASK_OFS),
2707                 readl(mmio + hpriv->irq_cause_ofs),
2708                 readl(mmio + hpriv->irq_mask_ofs));
2709
2710 done:
2711         return rc;
2712 }
2713
2714 /**
2715  *      mv_print_info - Dump key info to kernel log for perusal.
2716  *      @host: ATA host to print info about
2717  *
2718  *      FIXME: complete this.
2719  *
2720  *      LOCKING:
2721  *      Inherited from caller.
2722  */
2723 static void mv_print_info(struct ata_host *host)
2724 {
2725         struct pci_dev *pdev = to_pci_dev(host->dev);
2726         struct mv_host_priv *hpriv = host->private_data;
2727         u8 scc;
2728         const char *scc_s, *gen;
2729
2730         /* Use this to determine the HW stepping of the chip so we know
2731          * what errata to workaround
2732          */
2733         pci_read_config_byte(pdev, PCI_CLASS_DEVICE, &scc);
2734         if (scc == 0)
2735                 scc_s = "SCSI";
2736         else if (scc == 0x01)
2737                 scc_s = "RAID";
2738         else
2739                 scc_s = "?";
2740
2741         if (IS_GEN_I(hpriv))
2742                 gen = "I";
2743         else if (IS_GEN_II(hpriv))
2744                 gen = "II";
2745         else if (IS_GEN_IIE(hpriv))
2746                 gen = "IIE";
2747         else
2748                 gen = "?";
2749
2750         dev_printk(KERN_INFO, &pdev->dev,
2751                "Gen-%s %u slots %u ports %s mode IRQ via %s\n",
2752                gen, (unsigned)MV_MAX_Q_DEPTH, host->n_ports,
2753                scc_s, (MV_HP_FLAG_MSI & hpriv->hp_flags) ? "MSI" : "INTx");
2754 }
2755
2756 /**
2757  *      mv_init_one - handle a positive probe of a Marvell host
2758  *      @pdev: PCI device found
2759  *      @ent: PCI device ID entry for the matched host
2760  *
2761  *      LOCKING:
2762  *      Inherited from caller.
2763  */
2764 static int mv_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
2765 {
2766         static int printed_version;
2767         unsigned int board_idx = (unsigned int)ent->driver_data;
2768         const struct ata_port_info *ppi[] = { &mv_port_info[board_idx], NULL };
2769         struct ata_host *host;
2770         struct mv_host_priv *hpriv;
2771         int n_ports, rc;
2772
2773         if (!printed_version++)
2774                 dev_printk(KERN_INFO, &pdev->dev, "version " DRV_VERSION "\n");
2775
2776         /* allocate host */
2777         n_ports = mv_get_hc_count(ppi[0]->flags) * MV_PORTS_PER_HC;
2778
2779         host = ata_host_alloc_pinfo(&pdev->dev, ppi, n_ports);
2780         hpriv = devm_kzalloc(&pdev->dev, sizeof(*hpriv), GFP_KERNEL);
2781         if (!host || !hpriv)
2782                 return -ENOMEM;
2783         host->private_data = hpriv;
2784
2785         /* acquire resources */
2786         rc = pcim_enable_device(pdev);
2787         if (rc)
2788                 return rc;
2789
2790         rc = pcim_iomap_regions(pdev, 1 << MV_PRIMARY_BAR, DRV_NAME);
2791         if (rc == -EBUSY)
2792                 pcim_pin_device(pdev);
2793         if (rc)
2794                 return rc;
2795         host->iomap = pcim_iomap_table(pdev);
2796
2797         rc = pci_go_64(pdev);
2798         if (rc)
2799                 return rc;
2800
2801         /* initialize adapter */
2802         rc = mv_init_host(host, board_idx);
2803         if (rc)
2804                 return rc;
2805
2806         /* Enable interrupts */
2807         if (msi && pci_enable_msi(pdev))
2808                 pci_intx(pdev, 1);
2809
2810         mv_dump_pci_cfg(pdev, 0x68);
2811         mv_print_info(host);
2812
2813         pci_set_master(pdev);
2814         pci_try_set_mwi(pdev);
2815         return ata_host_activate(host, pdev->irq, mv_interrupt, IRQF_SHARED,
2816                                  IS_GEN_I(hpriv) ? &mv5_sht : &mv6_sht);
2817 }
2818
2819 static int __init mv_init(void)
2820 {
2821         return pci_register_driver(&mv_pci_driver);
2822 }
2823
2824 static void __exit mv_exit(void)
2825 {
2826         pci_unregister_driver(&mv_pci_driver);
2827 }
2828
2829 MODULE_AUTHOR("Brett Russ");
2830 MODULE_DESCRIPTION("SCSI low-level driver for Marvell SATA controllers");
2831 MODULE_LICENSE("GPL");
2832 MODULE_DEVICE_TABLE(pci, mv_pci_tbl);
2833 MODULE_VERSION(DRV_VERSION);
2834
2835 module_param(msi, int, 0444);
2836 MODULE_PARM_DESC(msi, "Enable use of PCI MSI (0=off, 1=on)");
2837
2838 module_init(mv_init);
2839 module_exit(mv_exit);