SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/ata/sata_mv.c

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