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